（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组成。