黑马程序员 集合（二）

------- android培训、java培训、期待与您交流！ ----------

讲到Collection我们不得不讲到它的兄弟Map，在Collection中其元素都是单个存在的，而在Map中的元素都是成键值对存在的。一对键值有对应的Key和Value，并且一个Key只能对应一个Value，而一个Value可以通过多个Key得到，也就是说Key之间不允许重复。

Map下有三个常用子类：HashTable，HashMap，TreeMap。其特性分别为：

• HashTable：底层为哈希表数据结构，不可以存入null键值，同步。
• HashMap：底层为哈希表数据结构，可以存入null键值，不同步。
• TreeMap：底层为二叉树结构，不同步，可以用于给Map的键进行排序。

在HashMap和TreeMap中的判断元素的唯一性方法其实和HashSet以及TreeSet一致。其实HashSet和TreeSet底层就是无Value的Map集合。

 

Map中常用的方法：

1、添加

value put(key ,value) ：返回前一个和key相关联的值，如果没有返回null；

2、删除

value clear() ：清空Map集合

value remove(Object key) ：删除指定key对应的键值对。

3、查找

Boolean containsKey(key) ;查找是否含有指定键

Boolean containsValue(Value) ;查找是否含有指定值

Boolean isEmpty() ;判断集合是否为空

4、获取

value get(key) :通过键获得对应的值，如果没有则返回null。可以通过判断是不是null来判断是不是包含指定的键。

Int size() ：获得键值对的个数。

entrySet() //返回一个元素类型是Map.Entry<K, V>的Set集合，包含Map所有的键值对。keySet() //返回一个包含map所以键值的Set集合。

 

下面是Map集合获得其元素的两种方法，由于Map中的元素都是成对存在的，而且存在唯一映射关系，所以我们只要取得其映射关系或Key值得集合就能得到全部的元素。

 

1.      获取Key值Set集合，遍历该集合使用getValue得到Value值。

class MapTest
{
	public static void main(String[] args)
	{
		HashMap<Student, String> hm = new HashMap<Student, String>();
		
		hm.put(new Student("lisi01", 21), "北京");
		hm.put(new Student("lisi01", 21), "天津");
		hm.put(new Student("lisi02", 22), "上海");
		hm.put(new Student("lisi03", 23), "武汉");
		hm.put(new Student("lisi04", 24), "南京");

		Iterator<Student> it1 = hm.keySet().iterator();
		while(it1.hasNext())
		{
			Student s = it1.next();
			String addr = hm.get(s);
			print(s + ".." + addr);
		}
	}
	
	public static void print(Object obj)
	{
		System.out.println(obj);
	}
}

 

2.   通过entrySet方法返回一个元素类型是Map.Entry<K, V>的Set集合，包含Map所有的键值对。

遍历这个Set集合可以得到每一个Map.Entry<K,V>元素，再使用getKey方法和getValue方法得到全部的Key和Value。

 

 

import java.util.*;
import java.util.Map.Entry;
/**
 * hashmap练习:存入对应的学生信息以及其学号
 *
 * hashmap一对键值存入，其中1个键只能有1个对应值，但多个键的值可以相同。可存入null值。不同步，高效。
 *
 * */
 
class person_hashmap
{
   private String name;
   private int age;
   person_hashmap(Stringname,int age)
   {
      this.name =name;
      this.age=age;
   }
   public String getName()
   {
      return name;
   }
   public int getAge()
   {
      return age;
   }
   public void getInfo()
   {
      System.out.println("name:"+name+" age:"+age);
   }
   public int hashCode()
   {
      return name.hashCode()+age*13;//hashcode和equals方法是判别一个元素是否相同的方法。
   }
   public boolean equals(Object obj)
   {
      if(!(obj instanceof person_hashmap))
         throw new ClassCastException("类型不匹配");
      person_hashmapph=(person_hashmap)obj;
      return ph.name.equals(this.name) && ph.age==this.age;
   }
}
 
public classHashMapPrt1 {
 
   public static void main(String[] args) {
  
      person_hashmapp1=new person_hashmap("zhangsan1",20);
      person_hashmapp2=new person_hashmap("zhangsan1",20);
      person_hashmapp3=new person_hashmap("zhangsan3",23);
      person_hashmapp4=new person_hashmap("zhangsan4",34);
      person_hashmap[]pArray={p1,p2,p3,p4};
     
      HashMap<Integer,person_hashmap> hm=new HashMap<Integer,person_hashmap>();
      for(int i=1;i<pArray.length+1;i++)
      {
         hm.put(i, pArray[i-1]);
      }
      hm.put(1, new person_hashmap("zhangsan1",30));//这里将键为1的值覆盖了，在运行结果可以看到
      Set<Map.Entry<Integer,person_hashmap>>enset=hm.entrySet();
      Iterator<Map.Entry<Integer,person_hashmap>>it=enset.iterator();
      while(it.hasNext())
      {
         Map.Entry<Integer,person_hashmap>en=it.next();
<span style="white-space:pre">	</span>//先通过Iterator取出Set中的元素,再通过元素的getKey方法和getValue方法取得键和值
         System.out.println("学号为"+en.getKey()+" 姓名为："+en.getValue().getName()
                +" 年龄为："+en.getValue().getAge());
      }
   }
 
}

 

输出结果为：

学号为1 姓名为：zhangsan1 年龄为：30

学号为2 姓名为：zhangsan1 年龄为：20

学号为3 姓名为：zhangsan3 年龄为：23

学号为4 姓名为：zhangsan4 年龄为：34

 

 

 

下面是一个应用：得到一个字符串中所有的字母及其个数

 

import java.util.*;
/**
 * hashmap练习:存入一个字符串统计其中各个字母都有几个
 *
 * hashmap一对键值存入，其中1个键只能有1个对应值，但多个键的值可以相同。可存入null值。不同步，高效。
 *  * 思路：1.将得到的字符串转换成字符数组
 *    2.将字符存入一个HashMap其中字符作为键，个数作为值
 *    3.遍历字符数组，每次存入字符的时候先以该字符作为键看返回值是否为空，为空则给其值赋1并存入HashMap
 *    4.若返回的值不为空则将返回值加1再存入HashMap
 *    5.调用HashMap的.entrySet()方法，返回映射关系的Set;
 *    6.遍历该Set分别取出其中的key和对应的Value即得到了全部的字符及其个数
 * */
class getNum_abc
{
   private int num;
   private char[] arr;
   privateHashMap<Character,Integer> hm=newHashMap<Character,Integer>();
   getNum_abc(Strings)
   {
      arr=s.toCharArray();//构造方法里将字符串转换成字符数组
   }
   public void getnum()
   {
      for(char c:arr)//将字符数组全部存入HashMap
      {
         if(hm.get(c)!=null)
            num=hm.get(c);
         num++;
         hm.put(c, num);
         num=0;
      }
      Set<Map.Entry<Character,Integer>>enset=hm.entrySet();
      for(Map.Entry<Character,Integer>me: enset)//遍历Set以取出全部key和value
      {
         System.out.print(me.getKey()+"("+me.getValue()+") ");
      }
   }
}
 
public classHashMapPrt2 {
 
   public static void main(String[] args) {
      getNum_abcb=new getNum_abc("abcasrecvav");
      b.getnum();
   }
 
}

 

输出结果为：

a(3) b(1) r(1) c(2) s(1) e(1) v(2)

 

泛型

泛型是JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。泛型要求在定义集合时，明确你要在集合中操作何种类型的数据，格式是通过<>来定义要操作的引用数据类型，如ArrayList<String>。这样就可以将运行时期出现的问题ClassCastException，转移到编译时期。方便于程序员解决问题。让运行时期问题减少、安全。同时也避免了强制转换的麻烦。当传入的类型不确定时，可以使用通配符?，也称为占位符。使用通配符的好处是可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩展性。

泛型限定：对泛型的上下限进行限定，明确泛型的范围。

     <? extends E>：可接收E类型或E类型的子类型，称之为上限。

     <? super E>：可接收E类型或E类型的父类型，称之为下限。

泛型类：当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

泛型方法：不同方法如果要操作不同类型的参数，而且类型还不确定，那么可以将泛型定义在方法上。

 

泛型使用实例

class Test<T>//泛型类
{
	private T t;
	public void setObject(T t)
	{
		this.t = t;
	}
	public T getObject()
	{
		return t;
	}

	public <E> void print(E e)//泛型方法
	{
		System.out.println(e);
	}
	public <T> void show(T t)
	{
		System.out.println(t);
	}
}


class FanxinTest
{
	public static void main(String[] args)
	{
		Test<String> t = new Test<String>();
		t.setObject("就是这么酷炫");
		System.out.println(t.getObject());
		
		t.show(4);
	}
}