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

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

一、JDK1.5--->泛型

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。

泛型的优点：

1，将运行时期出现的问题，如ClassCastException，转移到了编译时期，方便程序员解决问题，让运行时期问题减少。

2，避免了强制转换动作。

泛型的格式：通过<>来定义要引用的数据类型。如ArrayList<String> al = new ArrayList<String>();

其中，<>是用来接收类型的。当使用集合时，将集合中药存储的数据类型作为参数传递进去即可。

package 博客7_集合框架二;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class 泛型示例 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeSet<String> ts = new TreeSet<String>(new MyComparator());//添加了String类型的泛型
		ts.add("absd");
		ts.add("vabssdfd");
		ts.add("ggabsfd");
		ts.add("erabsd");
		ts.add("qwabsddff");
		
		Iterator<String> it = ts.iterator();
		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s);
		}
	}
}
class MyComparator implements Comparator<String>//按照字符串长度排序
{
	public int compare(String s1,String s2)
	{
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num == 0)
			return s1.compareTo(s2);
		return num;
	}
}

泛型类：加了泛型的类，扩展性强。

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

package 博客7_集合框架二;

class Work
{

}

class Util<QQ>
{
	private QQ q ;
	public void setObject(QQ q)
	{
		this.q= q;
	}
	public QQ getObject()
	{
		return q;
	}
}

public class 泛型类Demo {
	public static void main(String[] args) {
		Util<Work> u = new Util<Work>();
		u.setObject(new Work());
		Work w = u.getObject();
		System.out.println(w);
	}

泛型方法：泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作的类型不同，且不确定，就可以 将泛型定义在方法上。 

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

泛型定义在接口上的示例如下：

package 博客7_集合框架二;

interface Inter<T>
{
	void show(T t);
}
class MyInter<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println(t);
	}
}
public class 泛型定义在接口上 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyInter<String> mi = new MyInter<String>();
		mi.show("lalala");
	}

}

泛型限定：在泛型中，<?>代表通配符，也叫占位符。

泛型的限定：

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

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

package 博客7_集合框架二;

import java.util.*;

public class 泛型限定Demo
{
	public static void main(String[] args) 
	{
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Student("abc1"));
		ts.add(new Student("abc3"));
		ts.add(new Student("abc5"));
		ts.add(new Student("abc2"));
		printColl(ts);
		
		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
		ts1.add(new Worker("wabc---6"));
		ts1.add(new Worker("wabc---2"));
		ts1.add(new Worker("wabc---8"));
		ts1.add(new Worker("wabc---1"));
		printColl(ts1);
	}
	public static void printColl(TreeSet<? extends Person> ts)//泛型限定为Person或者Person的子类
	{
		Iterator<? extends Person> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}

class Comp implements Comparator<Person>//泛型限定为person或者person的子类
{
	public int compare(Person p1 ,Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
}
class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

二、Map集合
Map<K,V>接口：将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。

K：此映射所维护的键的类型。同KEY。

V：映射值的类型。同VALUE。

Map的特点：该集合存储键值对，一个一个往里存，且要保持唯一性。

Map

|--Hashtable：底层是哈希表，不可以存入null值，是同步的，但是效率低，已经不怎么使用。

|--Hashmap：底层是哈希表，允许使用null值，是不同步。所以效率高，替代了Hashtable。

|--Treemap：底层是二叉树，可以用于给map集合中的key排序。

Map集合的共性方法演示如下：

package 博客7_集合框架二;

import java.util.*;

public class Map集合共性方法 
{
	public static void main(String[] args)
	{
		method();
	}
	public static void method()
	{
		Map<String,String> map = new HashMap<String,String>();
		//添加元素,如果添加了相同的键，那么后面的值会替换原有的值，并返回被替换的值。
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		//是否包含元素
		//sop("contains:"+map.containsKey("022"));
		//删除元素
		//sop("remove:"+map.remove("02"));
		//删除后集合
		//sop("操作后的集合："+map);
		//获取元素
		sop("get:"+map.get("02"));//可以通过get方法返回的值是否为空来判断这个值是否存在
		//获取集合中所有的值
		Collection<String> coll = map.values();
		sop(coll);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

Map集合的两种取出方式：

1，keySet方式：将map集合中所有的键存入到Set集合中，因为Set集合具备迭代器，所以可以通过迭代的方式取出所有的键，再根据get方法，获取每一个键所对应的值。

package 博客7_集合框架二;

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

public class Hashmap取出方式之keySet {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		//先获取map集合所有键的Set集合，通过keySet（）方法
		Set<String> keyset= map.keySet();
		//使用Set集合的迭代器
		Iterator<String> it = keyset.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			sop("key::"+key);
			sop("value----"+map.get(key));
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

2，通过entruSet：将map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是map.Entry。

<pre name="code" class="java">package 博客7_集合框架二;

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

public class Map集合的取出方式之entrySet 
{
	public static void main(String[] args)
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		//将map集合中的映射关系取出，存入到Set集合中
		Set<Map.Entry<String, String>> entryset = map.entrySet();
		Iterator<Map.Entry<String, String>> it = entryset.iterator();
		while(it.hasNext())
		{
			Map.Entry<String, String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			sop(key+"::"+value);
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

Map.Entry中Entry也是一个接口，并且是Map接口中的一个内部接口。