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);
}
}