黑马程序员——Java基础——集合（二）

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、泛型

先来看一段代码

		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add(2);
		
		for(Iterator it = al.iterator();it.hasNext();)
		{
			String s = (String) it.next();
			System.out.println(s+":"+s.length());
		}

结果如上图，出现了ClassCastException异常。在集合中先存入String类型的值，又存入Integer类型的值是符合语法要求的，但是如果使用类型转换时就会在运行时发生异常。那么有没有办法避免这种问题的发生呢？

JDK1.5后针对这种安全问题就引入了泛型。可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，将运行时出现的问题转移到了编译时期，更方便。

1.泛型的格式：通过<>来定义要操作的引用数据类型。

相同的例子运用泛型时的代码：

		ArrayList<String> al = new ArrayList<String>();
		al.add("java01");
		al.add("java02");
		al.add(2);
		
		for(Iterator<String> it = al.iterator();it.hasNext();)
		{
			String s = (String) it.next();
			System.out.println(s+":"+s.length());
		}

运用泛型后，在编译时就出现了错误。

2.泛型的使用

除了在集合中的语法中使用泛型以外，还可以有以下三种使用方式：

1）泛型类

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，JDK1.5以后可以使用泛型。泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所以要操作的类型就已经固定了。

当一个变量被声明为参数时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用，因为静态成员是被所有参数化的类共享的，所以静态成员不应该有类级别的类型参数。

class GenericClass <Type> 
{
	private Type t;

	public Type getT() {
		return t;
	}

	public void setT(Type t) {
		this.t = t;
	}
	public static void get()
	{
		return  t;
	}
	
}

2）泛型接口

泛型也可以定义在接口上

interface GenericInterface <Type>
{
	public void show(Type t);

}

3）泛型方法

如果不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。方法中上的泛型可以不和类泛型相同。

静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class GenericMethod <Type1> 
{
	private Type1 t1;

	public Type1 getT() {
		return t1;
	}

	public void setT(Type1 t1) {
		this.t1 = t1;
	}
	//用于放置泛型的类型参数的<>应出现在方法的其他所有修饰符之后和在方法的返回类型之前
	public <Type2> void show2(Type2 t2)
	{
		System.out.println(t2);
	}
	public static <Type3> void show3(Type3 t3)
	{
		System.out.println(t3);
	}
	
}

3.通配符

？：泛型中的通配符，用来代替具体类型。可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩展性。

泛型限定：

？ extends E: 可以接收E类型或者E的子类型。上限。

？ super E: 可以接收E类型或者E的父类型。下限

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

class Person
{
	private String name;
	Person(String name)
	{
		this.setName(name);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}

}
public class GenericClassDemo {

	public static void main(String[] args) {
		
		ArrayList<Person> al1 = new ArrayList<Person>();
		al1.add(new Person("person01"));
		al1.add(new Person("person02"));
		al1.add(new Person("person03"));
		print(al1);

		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("stu01"));
		al2.add(new Student("stu02"));
		al2.add(new Student("stu03"));
		print(al2);
	}
	
	public static  void print(ArrayList<? extends Person> al)
	{
		for(Iterator<? extends Person> it = al.iterator(); it.hasNext();)
		{
			System.out.println(it.next().getName());
		}
	}

}

4.反射泛型

1）通过反射获取泛型的实际参数类型

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
import java.util.TreeMap;

class Demo
{
	public Map<String,Integer> tm = new TreeMap<String, Integer>();
}

class ReflectCol {
	public static void main(String[] args) throws NoSuchFieldException,
			SecurityException {
		
		//通过类的字节码获取名为tm的变量对象
		Field f = Demo.class.getField("tm");

		//获取变量对象的参数化类型
		Type type = f.getGenericType();

		ParameterizedType pt = (ParameterizedType) type;
		
		//获取并打印基本类型名称
		Type btype = pt.getRawType();

		System.out.println("基本类型："+btype.getTypeName());

		//获取并打印实际类型参数名称
		Type[] types = pt.getActualTypeArguments();

		for(Type t : types)
		{
			System.out.println("泛型实际参数类型："+t.getTypeName());
		}

	}
}

2）在定义泛型的集合中添加其他类型的元素

//有一个ArrayList<Integer> list=new ArrayList<Integer>();
//将一个String类型的字符串放进集合中
import java.lang.reflect.Method;
import java.util.ArrayList;

class ReflectCol
{
public static void main(String[] args) throws Exception{
	 // TODO Auto-generated method stub
	 ArrayList<Integer> list = new ArrayList<Integer>();
	 
	 list.add(1);
	 list.add(3);
	 list.add(5);
	 list.add(7);

	 System.out.println(list);
	 
	 Method m1=list.getClass().getMethod("add",Object.class);
	 
	 m1.invoke(list,"hello");

	 System.out.println(list);


	 }
}

二、Map

1.Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

2.Map常用子类

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。

|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的，将hashtable替代

|--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序。

3.常用方法：

1）添加

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

void putAll(Map<? extends Key，? extends Value> m)：从指定映射中将所有映射关系复制到此映射中

2）删除

void clear()：清空map集合。

value remove(Object key)：根据指定的key删除这个键值对。

3）判断

boolean containsKey(key)：如果此映射包含指定键的映射关系，则返回true。

boolean containsValue(value)：如果此映射将一个或多个键映射到指定值，则返回true

boolean isEmpty()：如果此映射未包含键-值映射关系，则返回true

4）获取

value get(key)：通过键获取值，如果没有该键返回null。所以可以通过返回null，来判断是否包含指定键。

int size()：获取键值对个数。

Collection<Value> values()：返回此映射中包含的值的集合

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

public class MapDemo {

	public static void main(String[] args) {

		// 创建一个Map集合
		Map<String, Integer> map = new HashMap<String, Integer>();
		//添加元素
		map.put("zhangsan01", 10);
		map.put("zhangsan02", 11);
		map.put("zhangsan03", 12);
		map.put("zhangsan01", 10);
		
		//获取该集合的元素个数
		System.out.println("该集合包含的元素个数："+map.size());
		
		//判断是否有指定元素
		System.out.println("集合中有没有zhangsan02的元素："+map.containsKey("zhangsan02"));
		
		//根据指定键删除整个键值对，返回对应的值
		System.out.println("zhangsan03对应的值是："+map.remove("zhangsan03"));
		
		//获取Map集合中所有的值 
		Collection<Integer> cols = map.values();
		System.out.print("Map集合剩下元素的值：");
		for(Integer col : cols)
		{
			System.out.print(col+",");
		}		
	}

}

4.获取map集合中所有元素的两种方式

Map集合的取出原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

1）Set <Key> keySet()：将map集合中的键都取出存放到set集合中，对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

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

public class MapDemo {

	public static void main(String[] args) {

		// 创建一个Map集合
		Map<String, Integer> map = new HashMap<String, Integer>();
		//添加元素
		map.put("zhangsan01", 10);
		map.put("zhangsan02", 11);
		map.put("zhangsan03", 12);
		map.put("zhangsan01", 10);
		
		//使用keyset方法获取Map集合中的所有元素
		Set<String> set = map.keySet();
		
		for(Iterator<String> it = set.iterator(); it.hasNext();)
		{
			String key = it.next();
			int value = map.get(key);
			System.out.println("key:"+key+",value:"+value);
		}

	}

}

2）Set <Map.Entry<Key,Value>> entrySet()：将map集合中的映射关系存入到了set集合中。这个关系的数据类型就是：Map.Entry

Entry就是Map接口中的内部接口；为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

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

public class MapDemo {

	public static void main(String[] args) {

		// 创建一个Map集合
		Map<String, Integer> map = new HashMap<String, Integer>();
		//添加元素
		map.put("zhangsan01", 10);
		map.put("zhangsan02", 11);
		map.put("zhangsan03", 12);
		map.put("zhangsan01", 10);
		
		//使用entryset方法获取Map集合中的所有元素
		Set<Entry<String, Integer>> set = map.entrySet();
		for(Iterator<Entry<String, Integer>> it = set.iterator(); it.hasNext() ;)
		{
			Entry<String, Integer> en = it.next();
			String key = en.getKey();
			int value = en.getValue();
			System.out.println(key+":"+value);
		}
	

	}

}