6 Map
6.1 Map 特点和基本操作
Map 接口与 Collection 接口不同，这个接口的元素是“键值对”。其中，键值对的特点是：键不可以重复，值可以重复。
Map 接口中的一些基本操作罗列如下：
Object get(Object key)
这个方法完成的功能是，通过键对象 key，来找到相应的值对象。
put(Object key, Object value)
这个方法是把一个键值对放入 Map 中。如果键不存在，则在 Map 中新增一个键值对。如果键已存在，则把新值替换旧值。
System.out.println(map.get(“2002”)); map.put(“2002”, “Brazil”); System.out.println(map.get(“2002”)); map.put(“2002”, “China”); System.out.println(map.get(“2002”)); remove(Object key)
这个方法根据一个键，删除一个键值对。
Set keySet()
这个方法返回所有键的集合。由于在 Map 中，键没有顺序，且不可以重复，因此所有的键对象组成的就是一个 Set。也就是说，
keySet 方法返回的是一个 Set，这个
Set 就是所有键对象的集合。
Collection values()
values 方法返回类型是一个 Collection，返回的是所有值对象的集合。
containsKey / containsValue
这两个方法用来判断在 Map 中键是否存在，或者值是否存在。
size()
这个方法返回 Map 中键值对的个数
isEmpty()
判断 Map 是否为空
clear()
清空 Map
entrySet
这个方法返回值类型是一个 Set 集合，集合中放的是 Map.Entry 类型。这个方法是用来做键值对遍历的，在讲解遍历的时候还会给大家讲到。
6.2 遍历
首先先使用一个 Map 接口的实现类：HashMap。创建相应的 HashMap 对象，并放入一些初始值
import java.util.*; public class TestMap { public static void main(String args[]){ Map map = new HashMap(); map.put("2006", "Italy"); map.put("2002", "Brazil"); map.put("1998", "France"); map.put("1994", "Brazil"); } }
在这个 Map 的基础上，我们开始对 Map 进行遍历。由于 Map 管理的是键值对，因此对于 Map 而言，有多种遍历的方式：键遍历、键值遍历、利用 Map.Entry 进行键值遍历。
6.2.1 键遍历与键值遍历
键遍历指的是遍历所有的键。键遍历的实现非常简单：通过调用 Map 接口中的 keySet方法，就能获得所有键的集合。然后，就可以像遍历普通 Set 一样遍历所有键对象的集合。键遍历参考代码如下：
Set set = map.keySet(); Iterator iter = set.iterator(); while(iter.hasNext()){ System.out.println(iter.next()); }
键遍历输出结果如下：
2006
1998
2002
1994
可以看到，键遍历输出了集合中所有的键，并且，键并没有顺序。
在键遍历的基础上更进一步，能够遍历所有的键值对。思路如下：利用键遍历能够遍历所有的键，而在遍历键的时候，可以使用get 方法，通过键找到对应的值。键值遍历的参考代码如下：
Set set = map.keySet(); Iterator iter = set.iterator(); while(iter.hasNext()){ Object key = iter.next(); Object value = map.get(key); System.out.println(key + "--->" + value); }
键值遍历的结果如下：
2006--->Italy
1998--->France
2002--->Brazil
1994--->Brazil
可以看到，键值遍历时能够输出键值对这种一一对应的关系。
6.2.2 值遍历
除了键遍历以及键值遍历之外，Map 接口还有一种遍历方式：值遍历。值遍历表示的是遍历 Map 中所有的值对象。与键遍历类似，我们对 Map 进行值遍历的思路也很简单：首先利用 Map 的 values()方法获得 Map 中所有值的集合。需要注意的是，values()方法返回的是一个 Collection 类型的对象，因此，应当用迭代遍历的方式，遍历这个 Collection。参考代码如下：
Collection conn = map.values(); Iterator iter = conn.iterator(); while(iter.hasNext()){ System.out.println(iter.next()); }
这样，我们就遍历了 Map 中的所有值。输出结果如下：
Italy
France
Brazil
Brazil
6.2.3 利用 Map.Entry 进行遍历
在 Map 接口中，有一个方法叫做 entrySet。这个方法返回一个 Set 集合，这个集合中装的元素的类型是 Map.Entry 类型。Map.Entry 是 Map 接口的一个内部接口。这个接口封装了 Map 中的一个键值对。在这个接口中，主要定义了这样几个方法：
getKey() : 获得该键值对中的键
getValue(): 获得该键值对中的值
setValue()：修改键值对中的值
因此，利用 Map.Entry 也可以进行遍历。相关代码如下：
Set set = map.entrySet(); Iterator iter = set.iterator(); while(iter.hasNext()){ Map.Entry entry = (Map.Entry) iter.next(); System.out.println(entry.getKey() + "-->" + entry.getValue()); }
注意，在赋值的时候，应当把 iter.next 的返回值强转成 Map.Entry 类型才可以。结果如下：
2006-->Italy
1998-->France
2002-->Brazil
1994-->Brazil
可以看到，用 Map.Entry 进行遍历，以及使用 keySet()方法以及 get()方法进行键值，这两种遍历的结果是一样的。
6.3 实现类
Map 接口主要的实现类就是 HashMap 和 LinkedHashMap，此外还有一个使用较少的Hashtable。HashMap 的特点是：在判断键是否重复的时候，采用的算法是 Hash 算法，因此要求作为 HashMap 的键的对象，也应该正确覆盖 equals 方法和 hashCode 方法。LinkedHashMap 和 HashMap 之间的区别有点类似于 LinkedHashSet 和 HashSet 之间的区别：LinkedHashMap 能够保留键值对放入 Map 中的顺序。
要注意，HashMap 和 Hashtable 有两方面的区别。一方面，这两个实现类一个是重量级，一个是轻量级。这类似于 ArrayList 和 Vector 的区别，也就是说，Hashtable 中的所有方法都是同步方法，因此是线程安全的。另一方面，在于对 null 值的处理。
7 Comparable 与排序
7.1 Collections 类与 Comparable
在 java.util 包中，提供了一个 Collections 的类（注意这个类的名字，与我们的 Collection接口只相差最后一个字母 s）。这个类中所有的方法都是静态方法，也就是说，Collections类所有方法都能够通过类名直接调用。这个类为我们提供了很多使用的功能，例如：sort 方法，这个方法能够对 List 进行排序。再例如，max 方法可以找到集合中的最大值，而 min方法可以找到集合中的最小值，等等。
7.2 TreeSet 与 TreeMap
Set 接口有一个子接口：SortedSet，这个接口的特点是：元素不可重复，且经过排序。这个接口有个典型的实现类：TreeSet。要注意的是，因为 TreeSet 中要对对象进行排序，因此要求放入 TreeSet 接口中的对象都必须实现 Comparable 接口。
8 5.0 新特性：foreach 循环
foreach 循环主要要解决的是遍历的问题。对于 List 来说，我们可以采用 for 循环遍历，而对于 Set 而言，我们只能采用迭代遍历。相对 for 循环遍历而言，迭代遍历的代码比较繁琐和复杂。例如，对于一个 Set 而言，采用迭代遍历的代码如下：
Iterator iter = set.iterator(); while(iter.hasNext()){ Object value = iter.next(); System.out.println(value); }
为了简化遍历的代码，在 5.0 中引入了 foreach 循环。基本语法如下：
for(变量 : 集合){ 循环体; } for(Object value : set){ System.out.println(value); } 此外，foreach 循环还能够用来遍历数组。例如下面的代码： String[] ss = new String[]{“hello”, “world”, “java”}; for(String obj : ss){ System.out.println(obj); }
9 5.0 新特性：泛型
ArrayList 为了设计的更加通用，其内部保存数据的时候，保存数据的时候都采用的是 Object 类型。因为只有设计成这样，ArrayList 才能用来保存所有的 Java 对象。但是，如果把 ArrayList 设计成这样的话，就会造成之前的两个问题：我们无法象定义某个类型的数组那样，定义一个专门用于存放某个类型对象的集合。因此，我们称传统的集合对象是：类型不安全的。5.0 引入的泛型机制能够很好的解决我们上面所说的问题。
9.1 泛型的基本使用
使用 5.0 的泛型机制非常简单。例如，我们希望创建一个只能用来保存 Dog 对象的 List，可以使用如下代码：
List<Dog> list = new ArrayList<Dog>();
注意，跟原有的代码相比，在 List 接口和 ArrayList 后面，都有个后缀：。这表明，创建的 ArrayList 只能够放置 Dog 类型。此时，如果对 list 放入非 Dog 类型对象，则会产生一个编译错误，示例如下：
list.add(new Dog()); //OK list.add(new Cat()); //!编译错误
对 Set 集合使用泛型的方法，和 List 接口使用泛型的方法类似，在此不再赘述。
9.2 泛型与多态
请看下面的例子：
List dogList = new ArrayList();
List aniList = dogList; //! 编译出错！
这两行代码中，第一行编译正确，第二行编译出错。在第一行代码中，把一个 ArrayList直接赋值给一个 List类型的引用。在这个赋值过程中，类型里有多态（把 ArrayList 赋值给 List），但是泛型是一样的（均是 Dog 的泛型）。在第二行代码中，把一个 List赋值给一个 List，这样赋值是错误的！在这个过程中，类型中没有多态（List 是相同的），而泛型有多态（一个是 Dog 的泛型，一个是 Animal 的泛型）。这句话会导致一个编译错误！
请记住这个结论：类型可以有多态，但是泛型不能够有多态！
9.3 自定义泛型化类型
现在我们定义一个类，用来表示“一对”这个概念。如果不用泛型的话，示例代码如下：
class Pair{ private Object valueA; private Object valueB; public Object getValueA() { return valueA; } public void setValueA(Object valueA) { this.valueA = valueA; } public Object getValueB() { return valueB; } public void setValueB(Object valueB) { this.valueB = valueB; } } public class TestPair { public static void main(String[] args){ Pair p = new Pair(); p.setValueA(new Dog()); p.setValueB(new Dog()); } }
可以看到，Pair 类为了尽可能通用，使用了 Object 类型来保存一对值。但是这样就会有类型方面的问题，例如：
p.setValueA(new Dog());
p.setValueB(new Cat());
这样，这个代码就把一只猫和一条狗硬生生配成了一对，显然，我相信无论是猫还是狗都不会愿意的。
class Pair<T>{ private T valueA; private T valueB; public T getValueA() { return valueA; } public void setValueA(T valueA) { this.valueA = valueA; } public T getValueB() { return valueB; } public void setValueB(T valueB) { this.valueB = valueB; } } public class TestPair { public static void main(String[] args){ Pair<Dog> p = new Pair<Dog>(); p.setValueA(new Dog()); p.setValueB(new Dog()); // p.setValueA(new Cat()); 编译出错！ } }
