黑马程序员--集合框架（2）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

泛型

泛型：jdk1.5版本，出现的技术。是一个安全机制。
  
 
泛型技术的由来：
 集合中可以存储任意类型对象，但是在取出时，如果要使用具体对象的特有方法时，需要进行向下转型，
 如果存储的对象类型不一致，在转型过程中就会出现ClassCastException异常。
 这样就给程序带来了不安全性。
 
 在jdk1.5以后就有了解决方案。就是泛型技术。  
 解决方案就是，在存储元素时，就不允许存储不同类型的元素。
 存储了就编译失败。
 所以就需要在存储元素时，在容器上明确具体的元素类型。这其实和数组定义很像。
   
好处：
1，将运行时期的ClassCastException异常转移到了编译事情，进行检查，并以编译失败来体现。
     这样有利于程序员尽早解决问题。
2，避免了向下转型(强转)的麻烦

package cn.itcast.api.p4.generic.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import cn.itcast.bean.Person;
import cn.itcast.bean.Student;

public class GenericAdvDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("lisi1",21));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		
		print(al);
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("xiaoming1",21));
		al2.add(new Student("xiaoming2",22));
		al2.add(new Student("xiaoming3",23));
		
		print(al2);
		/*
		 * 泛型的限定：
		 * 		明确具体类型代表一个类型。
		 * 
		 *		明确?代表所有类型。
		 *
		 *		能不能对操作的类型限制在一个范围之内呢？
		 *		比如：定义一个功能，只操作Person类型或者Person的子类型。 
		 *		这时可以用 ? extends E:接收E类型或者E的子类型。这就是上限。 
		 *		下限：? super E: 接收E类型或者E的父类型。
		 *		
		 *
		 */
	}
	
	public static void print(Collection<? extends Person> coll){
		
		Iterator<? extends Person> it = coll.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
	}

}

 

什么时候写泛型呢？
先简单理解：只要在使用类或者接口时，该类或者接口在api文当描述时都带着<>就需要在使用时，定义泛型。 
其实，泛型无非就是通过<>定义了一个形式参数。专门用于接收具体的引用类型。
在使用时，一定要传递对应的实际参数类型。
集合中泛型的应用特别多见。

泛型的擦除：
 泛型技术是用于编译时期的技术，编译器会按照<>中的指定类型对元素进行检查，
 检查不匹配，就编译失败，匹配，就编译通过，通过后，生产的class文件中是没有泛型的。这就成为泛型的擦除。
 
泛型的补偿：
 运行时，可以根据具体的元素对象获取其具体的类型。并用该类型对元素进行自动转换。

----------------------------------------------------------------------------

集合框架中的另一个顶层接口，Map。

Map:用于存储具备着对应关系的键和值。
        而且要保证键的唯一性。
        一次存储一对儿元素。
 
  Collection一次存储一个元素，称之为单列集合。
  Map集合一次存储一对儿元素，称之为双列集合。

Map常见方法：
1，添加。
 v put(k,v):
 void putAll(map);

2，删除。
 void clear():清空集合。
 v remove(key):通过键删除元素，并返回对应的值。

3，判断。
 boolean containsKey(key);
 boolean containsValue(value);
 boolean isEmpty();

4，获取。
 value get(key):根据键获取值。如果键不存在，返回null。可以用来判断一个集合中是否存在某一个键。

5，获取map中所有的元素(对应关系)。
 Map是不具备迭代器的，获取原理就是将map集合先转成set集合。然后在使用迭代器。
 Set<key> keySet();
 Set<Map.Entry<key,value>> entrySet();
 Colection<value> values();获取map集合中所有的值。

 ----------------------------------------------------------------------------------

Map体系:
 |--Hashtable:底层是哈希表数据结构，是线程同步的，不允许null作为键，null作为值。
 |--HashMap：底层是哈希表数据结构，是线程不同步的，允许null作为键，null作为值。替代了Hashtable。
 |--TreeMap：可以对Map集合中的键进行指定顺序的排序，默认是使用键的自然顺序。当然也可以使用比较器。

package cn.itcast.api.p1.map.demo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		/*
		 * 现在准备存储一些有对应关系的元素，
		 * 比如学生的姓名和学号。而且学号是唯一的。
		 * 学号和姓名之间存在对应的关系。
		 * 使用到了map集合。 
		 * key的类型是：Integer
		 * value的类型是：String
		 */
		
		Map<Integer,String> map = new HashMap<Integer,String>();
		mapMethodDemo2(map);
		
	}
	
	/*
	 * 演示values方法。获取map集合中所有的值。
	 */
	public static void mapMethodDemo4(Map<Integer,String> map){
		map.put(4, "lisi");
		map.put(1, "qianyi");
		map.put(3, "zhangsan");
		map.put(7, "zhouqi");
		
		//通过values()获取map中所有的值。返回的是Collection，因为值是重复的。 
		Collection<String> coll = map.values();
		Iterator<String> it = coll.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	}
	
	/*
	 * 演示Map中的重要方式之二：Set<Map.Entry<k,v>> entrySet();
	 * Map.Entry ： 其实entry就是Map接口中的一个内部接口而已。
	 * 
	 * public interface Map{
	 * 		public static interface Entry{// 内部接口。 
	 * 		}
	 * }
	 * 
	 * 
	 * class  Demo  implements Map.Entry{
	 * }
	 */
	public static void mapMethodDemo3(Map<Integer,String> map){
		map.put(4, "lisi");
		map.put(1, "qianyi");
		map.put(3, "zhangsan");
		map.put(7, "zhouqi");
		
		//通过map集合的entrySet，将键值映射关系存储到Set集合中。 
		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
		
		//通过set集合获取迭代器。 
		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();
			System.out.println(key+"----"+value);
		}
		
	}
	
	/*
	 * 演示Map中重要的方法之一：Set<key>  keySet();
	 */
	
	public static void mapMethodDemo2(Map<Integer,String> map){
		map.put(4, "lisi");
		map.put(1, "qianyi");
		map.put(3, "zhangsan");
		map.put(7, "zhouqi");
		
//		通过keySet方法获取map集合中所有的键集
		Set<Integer> keySet = map.keySet();
		
		//通过Set集合的迭代器获取所有的键。
		Iterator<Integer> it = keySet.iterator();
		while(it.hasNext()){
			Integer key = it.next();
			//通过map集合的get方法可以获取键对应的值。 
			String value = map.get(key);
			System.out.println(key+"::::"+value);
		}
	}
	
	
	
	public static void mapMethodDemo(Map<Integer,String> map){
		
		//1,添加元素。
		map.put(4, "lisi");
		map.put(1, "qianyi");
		map.put(3, "zhangsan");
		map.put(7, "zhouqi");
		
		//put方法的返回值。在map集合中，存储了相同的键，新值会替换旧值。put方法会返回旧值。
//		System.out.println(map.put(5,"haha"));
		
		//2,删除元素。
//		System.out.println(map.remove(4));
		
		//3,获取元素。
		System.out.println(map.get(7));
		
		System.out.println(map);
	}

}

当分析问题时，发现其中存在着映射关系，这时应该想到两个容器，一个是map，一个是数组。
如果映射关系的一方是有序的编号(可以作为索引)，而且映射关系的个数确定，建议使用数组。
否则，就使用map集合。
凡是映射关系的出现，都可以使用查表法的思想去解决问题。

其他集合什么时候使用呢？

如果要保证元素的唯一性，不存在映射关系，必须先考虑使用Set集合。
如果不需要保证唯一性，直接考虑List集合。