Java学习札记——集合框架二 Map

众所周知，Collection是单列集合，即一个元素中只能有一个值，所以，有时候在使用起来就有一点局限了，无法表示一种对应的关系。而Map就恰恰弥补了这个不足，在存储数据时，是以键值对，即一个键对应一个值，一堆一堆往里存，同时还要保证了键的唯一性，就说，一个键只能对应一个值，但是值可就不一定唯一了，这世界上相同的事多了去了。

常用的实现了Map接口的对象有三个，如下：

|--Hashtable 底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。jdk1.0效率低
|--HashMap   底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。jdk1.2效率高
|--TreeMap   底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序。

Map中一些常用的方法：

1、添加。
V put(K key, V value) 
void putAll(Map<? extends K,? extends V> m) 

2、删除。
clear().
V remove(Object key) 

3、判断。
boolean containsKey(Object key) 
boolean containsValue(Object value)
boolean isEmpty() 


4、获取。
get(Object key) 
int size() 
values() 

entrySet() 
keySet() 

使用起来和List、Set方法类似，简单举一例说明：

public class  MapDemo
{
	public static void main(String[] args) 
	{
		//put方法会返回原来对应的键值
		Map<String,String> map = new HashMap<String,String>();
		//添加元素 ，如果出现添加时，相同的值，那么后天加的值会覆盖原有键对应的值
		//put方法会返回被覆盖的值
		System.out.println("put:" + map.put("01","zhangsan1"));
		System.out.println("put:" + map.put("01","wangwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");

		System.out.println("containsKey: " + map.containsKey("02"));
		//System.out.println("remove: " + map.remove("02"));
	
		System.out.println("get():" + map.get("02"));	

		map.put("04", null);
		System.out.println("get():" + map.get(null));	
		//可以通过get方法的返回值来判断一个键是否存在,通过返回空来判断

		//获取map集合中所有的值。
		Collection<String> coll = map.values();

		System.out.println(coll);

		System.out.println(map);
	}
}

Map 功能非常强大，是一个使用非常频繁的集合，主要就像前面描述的，因为Map具备了元素与元素之间的 映射关系！可以很好地解决元素对应的问题，这也是我们实际生活中很常见的，每个人都只有一个身份证号，每个老公都只有一个老婆（法律的范围内）等等。。。。

有这样一个例子：
一个学校有多个班级，每个班级都有一个名称,每个班级又有很多学生，学生又有学号。。。

可以这么理解 

School ——>  | 高三三班 

| 01好学生   张三

| 10号学生   李四

       | 高二一班这体现了数学里的映射的关系，又不完全是，有点类似的感觉

| 02好学生   王五

| 08号学生    赵六

... ...

这个该怎么用Map表示、操作呢？

请看下例

class Student
{
	private String id;
	private String name;
	Student(String id,String name)
	{
		this.id = id;
		this.name = name;
	}
	public String toString()
	{
		return this.id + "..." + this.name;
	}
}
class  MapTest
{
	public static void demo()
	{
		HashMap<String,List<Student>> gaozhong = new HashMap<String,List<Student>>();
		List<Student> gaosan = new ArrayList<Student>();
		List<Student> gaoer = new ArrayList<Student>();
		<span style="font-family: Arial, Helvetica, sans-serif;">gaozhong</span>.put("高三三班",<span style="font-family: Arial, Helvetica, sans-serif;">gaosan</span>);
		<span style="font-family: Arial, Helvetica, sans-serif;">gaozhong</span>.put("高二一班",gaoer);
		gaosan.add(new Student("01","zhangsan"));
		gaosan.add(new Student("10","lisi"));
		gaoer.add(new Student("02","wangwu"));
		gaoer.add(new Student("08","zhaoliu"));

		for(Iterator<String> it = gaozhong.keySet().iterator();it.hasNext();)
		{
			String roomName = it.next();
			List<Student> room = gaozhong.get(roomName);
			System.out.println(roomName);
			getInfos(room);
		}

	}

	public static void getInfos(List<Student> list)
	{
		for(Iterator<Student> it = list.iterator();it.hasNext();)
		{
			Student s = it.next();
			System.out.println(s);
		}
	}
	public static void main(String[] args) 
	{
		demo();
	}

	public static void getStudentInfo(HashMap<String , String> roomMap) 
	{
		for(Iterator<String> it = roomMap.keySet().iterator(); it.hasNext();)
		{
			String id = it.next();
			String name = roomMap.get(id);
			System.out.println("id :" + id + "...name :" + name);
		}
	}
}

集合补充：

java.util包中有个和Collection名字很像的东东 Collections ，jdk的解释 在 collection 上进行 此类完全由 操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

查看API可以知道，里面全是static方法，为我们操作集合带来了很大的便利，举个例子说明：

/*
集合框架的工具类演示
Collections：不能个Set排序

实现了一下API其中的几个简单的方法排序，按照某种规则排序 二分查找 按照某种排序后查找

达到和api同样的效果
*/
import java.util.*;
public class  CollectionsDemo
{
	public static void main(String[] args) 
	{
		sortDemo();
		//maxDemo();
		//binarySearchDemo();
	}

	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkk");
		list.add("qq");
		list.add("z");
<span style="white-space:pre">		</span>//排序 按照指定的字符串长度
		Collections.sort(list,new StrLenComparator());
		sop(list);	
		//在list中查找 aaaa 
	//	int index = Collections.binarySearch(list,"aaaa");
		int index = halfSearch2(list,"aaaa",new StrLenComparator());
		sop("index=" + index);

	}
	//二分查找
	public static int halfSearch(List<String> list,String key)
	{
		int max,min,mid;
		max = list.size() -1;
		min = 0;
		while(min <= max)
		{
			mid = (max+min)>>1; // /2
			String str = list.get(mid);
			int num = str.compareTo(key);
			if(num > 0)
				max = mid -1;
			else if(num < 0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}

	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)
	{
		int max,min,mid;
		max = list.size() -1;
		min = 0;
		while(min <= max)
		{
			mid = (max+min)>>1; // /2

			String str = list.get(mid);

			int num = cmp.compare(str,key);
			if(num > 0)
				max = mid -1;
			else if(num < 0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}

	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkk");
		list.add("qq");
		list.add("z");
		sop(list);
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list,new StrLenComparator());
		sop("max = " + max);
	}

	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkk");
		list.add("qq");
		list.add("z");

		sop(list);

		//Collections.sort(list ,new StrLenComparator());
		Collections.swap(list,1,2);
		sop(list);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class StrLenComparator implements Comparator<String>
{
	public int compare(String s1 ,String s2)
	{
		if(s1.length() > s2.length())
			return 1;
		else if(s1.length() < s2.length())
			return -1;
		else
			return s1.compareTo(s2);
	}
}