Java中Map和泛型

Map集合

Map:一次添加一对元素。Collection一次添加一个元素。Map集合也称双列集合，Collection集合称为单列集合。其实Map集合中存储的就是键值对。map集合中必须保证键的唯一性。

• 常用方法
  • 1.添加 : value put(key , value):返回前一个和key关联的值，如果没有返回null
  • 2.删除：
    • void clear():清空map集合
    • value remove(key):根据指定的key删除这个键值对
  • 3.判断
    • boolean containsKey(key) : 是否包含指定的key
    • boolean containsValue(value) : 是否包含指定的value
    • boolean isEmpty() : 是否为空
  • 4.获取
    • value get(key):通过键值对获取值，如果不包含该键的映射关系，则返回null，也可以通过判断是否返回null,判断是否包含key
    • int size():获取键值对个数
    • Collection values():获取map集合中所有values，返回values的Collection集合
• Map的遍历
  • 获取Map中所有的key的set集合，然后通过迭代器遍历该set集合

  Set<T> keySet  = map.keySet();
  Iterator<T> it = keySet.iterator();
  while(it.hasNext()){
      T key = it.next();
      Value value = map.get(key);
  }

• Map的遍历
  • 通过map.Entry<T,T>获取把映射关系作为对象的Set的集合。

Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer,String>> it = entrySet.iterator;
while(it.hasNext()){
    Map.Entry<Integer,String> me = it.next();
    Integer key = me.getKey();
    String value = me.getValue();
}

Map.Entry的原理如下：

//MyMap中存放键和值，MyEntry将键和值形成映射关系。MyEntry作为内部//接口提供访问map中的数据的方法。
interface MyMap{
   public static interface MyEntry{
         void getKey();
    }
}
Class MyDemo implements MyMap.MyEntry{
    public void getKey(); 
}

• Map常用的子类
  • Hashtable:内部结构是哈希表，是同步的。不予许null作为键/值。
    • Properties:用来存储键值对型的配置文件。
  • HashMap:内部结构是哈希表，不是同步的。允许null作为键/值
  • TreeMap:内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序

//将Person对象作为键，将归属地作为值存入HashMap中，如何保证实例化出的两个相同的姓名、相同年龄的Person为同一键？
//重写Person类的hashCode与equals方法
public Class Person{
    public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + ((age == null) ? 0 : age.hashCode());
	result = prime * result + ((name == null) ? 0 : name.hashCode());
	System.out.println(name+":"+age+"::::::result:"+result);
	return result;
	}
    public boolean equals(Object obj) {
	if (this == obj)
			return true;
	if (obj == null)
			return false;
	if (getClass() != obj.getClass())
		return false;
	Student other = (Student) obj;
	if (age == null) {
		if (other.age != null)
			return false;
	} else if (!age.equals(other.age))
			return false;
	if (name == null) {
		if (other.name != null)
			return false;
	} else if (!name.equals(other.name))
		return false;
	return true;
 }
}

• • TreeMap对存入的键实现排序的方法(与TreeSet一致，TreeSet底层就是一句TreeMap实现的)：
    • 让存入的元素自身具备比较功能，元素需要实现Compareble接口，覆盖compareTo方法。
    • 让集合自身具备比较功能，定义一个自定义的比较类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。

泛型

jdk1.5出现的安全机制。

泛型的优点

• 1.将运行时期的问题ClassCastException转到了编译时期
• 2.避免了强制转化的麻烦

泛型的使用场景

• 当操作的引用数据类型不确定的时候，就使用<>。将要操作的引用数据类型传入即可。
  其实<>就是一个用于接收具体引用数据类型的参数范围。在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型。
• 泛型技术是给编译器使用的技术，确保了类型的安全。运行时，会将泛型去掉，生成的Class文件中是不带泛型的，这个称为泛型的擦除。擦除的原因：为了兼容运行时的类加载器。
• 泛型的补偿：在运行时，通过获取元素的类型进行转化动作，不需要使用者再进行强制转换。
• 案例：自定义工具类操作其他对象
  • jdk1.5之后，使用泛型类来接收类中要操作的引用数据类型
  • 泛型类：当类中操作的引用数据类型不确定时，就使用泛型来表示
  • 未引入泛型之前，将QQ定义为Object类型，在编译阶段无法提示用户

/* 
*/
public class Tool<QQ>{
    private QQ q;
    public QQ getObject(){
        return q;
    }
    public void setObject(QQ object){
        this.q = object;
    }
}
.......
//使用时传入具体的对象
Tool<Worker> tool = new Tool<Worker>();
tool.setObject(new Worker());//编译正常
tool.setObject(new Student());//编译报错 

//未引入泛型之前
Tool tool = new Tool();
tool.setObject(new Student());//编译正常
......
 Worker worker =  (Worker)tool.getObject(); //运行时报错ClassCastException

• 将泛型定义在方法上

若希望在方法调用时，再传入泛型，则需将泛型定义在方法上。

//当在Tool类中新增show和print方法时
   public void show(QQ str){
		System.out.println(str);
	}
    public void print(QQ str){
		System.out.println(str);
	}
........
Tool<String> tool = new Tool<String>();
tool.show(new Integer(4));//此处报错，编译不通过，因为定义传入的泛型为String类型，此处传入Integer对象。
tool.show("089098afa");
//show方法应该改写为 泛型对象标识符放在修饰符之后，返回值之前。
//此时便可以调用tool.show(new Integer(4));
public <W> void show(W str ){
	System.out.println("show : " + str.toString());
}

• 注意：如在static修饰的静态方法内操作泛型对象，则泛型对象必须定义在方法上如在上例中

// Tool类内部新增method方法 此时编译不通过 静态方法的泛型对象需定义在方法上
public static  void method(QQ obj){
	System.out.println(obj.toString());
}
//应改为：
public static <Y> void method(Y obj){
  System.out.println(obj.toString());
}

• 实现泛型接口两个方式

//泛型接口，将泛型定义在接口上
interface Inter<T>{
   public void show(T t);
}
//在实现类上传入具体的类
class InterImpl implements Inter<String>{
    public void show(String t){
        System.out.println("show : " + t );
    }
}
// 在实现类上依然定义泛型，在使用时再传入具体的对象类型
class InterImpl2<Q> implements Inter<Q>{
	public void show(Q q) {
		System.out.println(" show : " + q);
	}
}

• 泛型中的通配符 ： 未知类型

public class GenericAdvanceDemo{
   public static void printCollection(Collection<?> list) {
		Iterator<?> it = list.iterator();
           while(it.hasNext()){
        	  System.out.println(it.next());
           }
	} 
}
// 效果和如下代码类似
public class GenericAdvanceDemo{
   public static <T> void printCollection(Collection<T> list) {
		Iterator<T> it = list.iterator();
           while(it.hasNext()){
        	  System.out.println(it.next());
           }
	} 
}