（4.2）TreeSet① 必须放入同类的对象。因为默认会进行排序，否则可能会发生类型转换异常.我们可以使用泛型来进行限制。Set treeSet = new TreeSet();
treeSet.add(1);     //添加一个 Integer 类型的数据
treeSet.add("a");   //添加一个 String 类型的数据
System.out.println(treeSet);  //会报类型转换异常的错误② 如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口，所以在其中不能放入null元素。

TreeSet的排序：
① 自动排序：添加自定义对象的时候，必须要实现 Comparable 接口，并要覆盖 compareTo(Object obj) 方法来自定义比较规则。
如果 this > obj，返回正数 1；
如果 this < obj，返回负数 -1；
如果 this = obj，返回 0 ，则认为这两个对象相等。
其中，数值类型比较数值大小，char和string类型比较unicode值的数值大小。

 1 ② 定制排序: 当需要把一个对象放入 TreeSet 中，需要重写该对象对应的 equals() 方法，并保证该方法与 compareTo(Object obj) 方法有一致的结果。
 2
 3 public class TreeSetTest {
 4     public static void main(String[] args) {
 5         Person p1 = new Person(1);
 6         Person p2 = new Person(2);
 7         Person p3 = new Person(3);
 8
 9         Set<Person> set = new TreeSet<>(new Person());
10         set.add(p1);
11         set.add(p2);
12         set.add(p3);
13         System.out.println(set);  //结果为[1, 2, 3]
14     }
15 }
16
17 class Person implements Comparator<Person>{
18     public int age;
19     public Person(){}
20     public Person(int age){
21         this.age = age;
22     }
23     @Override
24     /***
25      * 根据年龄大小进行排序
26      */
27     public int compare(Person o1, Person o2) {
28         // TODO Auto-generated method stub
29         if(o1.age > o2.age){
30             return 1;
31         }else if(o1.age < o2.age){
32             return -1;
33         }else{
34             return 0;
35         }
36     }
37
38     @Override
39     public String toString() {
40         // TODO Auto-generated method stub
41         return ""+this.age;
42     }
43 }

三个 Set 接口的实现类比较：共同点：
① 都不允许元素重复。
② 都不是线程安全的。解决办法：Set set = Collections.synchronizedSet(set 对象);
不同点：
① HashSet：不保证元素的添加顺序，底层采用哈希表算法，查询效率高。判断两个元素是否相等，equals()方法返回true且hashCode()值相等。因此，存入HashSet中的元素要覆盖equals()方法和hashCode()方法。
② LinkedHashSet：HashSet 的子类，底层采用哈希表算法以及链表算法，既保证了元素的添加顺序，也保证了查询效率。但是整体性能要低于 HashSet。　
③ TreeSet：不保证元素的添加顺序，但是会对集合中的元素进行排序。底层采用 红-黑树算法（树结构比较适合范围查询）。

 1 public class Collection {
 2     public static void main(String[] args) {
 3         Map<String, Object> hashMap = new HashMap<>();
 4         // 添加元素到Map中
 5         hashMap.put("key1", "value1");
 6         hashMap.put("key2", "value2");
 7         hashMap.put("key3", "value3");
 8         hashMap.put("key4", "value4");
 9         hashMap.put("key5", "value5");
10
11         // 删除Map中的元素,通过key的值
12         hashMap.remove("key1");
13         // 通过get(key)得到Map中的value
14         Object str1 = hashMap.get("key2");
15
16         // 可以通过添加方法来修改Map中的元素
17         hashMap.put("key2", "value22");
18
19         // 第一种遍历：通过map.values()得到value集合。缺点是不能遍历key。
20         java.util.Collection<Object> value = hashMap.values();
21         for (Object obj : value) {
22             System.out.println(obj);
23         }
24
25         // 第二种遍历：通过map.keySet()得到key集合，然后通过get(key)得到value。
26         Set<String> set = hashMap.keySet();
27         for (String str : set) {
28             System.out.println(str + "=" + hashMap.get(str));
29         }
30
31         // 第三种遍历：通过Map.entrySet()得到 Map的Entry集合，然后遍历。（推荐）
32         Set<Map.Entry<String, Object>> entrys = hashMap.entrySet();
33         for (Map.Entry<String, Object> entry : entrys) {
34             String key = entry.getKey();
35             Object value2 = entry.getValue();
36             System.out.println(key + "=" + value2);
37         }
38
39         // 第四种遍历：通过Map.entrySet使用iterator遍历key和value。
40         Iterator<Entry<String, Object>> it = hashMap.entrySet().iterator();
41         while (it.hasNext()) {
42             Entry<String, Object> entry = it.next();
43             System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
44         }
45
46         System.out.println(hashMap);
47     }
48 }

value22
value5
value3
value4
----------------
key2=value22
key5=value5
key3=value3
key4=value4
----------------
key2=value22
key5=value5
key3=value3
key4=value4
----------------
key= key2 and value= value22
key= key5 and value= value5
key= key3 and value= value3
key= key4 and value= value4
----------------
{key2=value22, key5=value5, key3=value3, key4=value4}

Map接口的常用实现类：
① HashMap：底层是哈希表。特点是key是无序插入，且key不能重复。key判断重复标准：key1和key2是否equals为true且hashCode相等。非线程安全。
② TreeMap：底层是红黑树。特点是key是无序插入，但是会自动升序排序，且key不能重复。key判断重复标准是：compareTo/compare的返回值是0。非线程安全。
③ LinkedHashMap：底层是链表和哈希表。特点是按添加的先后顺序进行有序插入，且key不能重复。key判断重复标准同HashMap。非线程安全。
④ HashTable：底层是哈希表，是HashMap的前身（类似于Vector是ArrayList的前身）。打死都不要用。线程安全。
⑤ Properties：HashTable的子类，要求键、值都为String类型。用来加载资源文件（.properties类型文件）。注意：
① 定义Map时，key通常使用不可变类string，把key作为value的唯一值。
② HashMap、TreeMap、LinkedHashMap都是非线程安全的，但是性能高。解决方案：Map map = Collections.synchronizedMap( Map对象 );
③ HashTable线程安全，但是性能低。

Map 和 Set 集合的关系：
① 都有几个类型的集合。HashMap和HashSet的底层都是哈希表，TreeMap和TreeSet的底层都是红-黑树，LinkedHashMap和LinkedHashSet的底层都是哈希表和红-黑树。
② 分析 Set 的底层源码，我们可以看到，Set 集合就是由Map集合的Key组成。