概述

　　List、Set接口都是继承于Collection主接口，而Map为独立接口

　　1、List接口下有ArrayList、Vector、LinkedList实现类

　　2、Set接口下有HashSet、LinkedHashSet、TreeSet实现类

　　3、Map下有HashMap、LinkedHashMap、Hashtable、TreeMap实现类

特点

　　Collection接口：

　　　　——List接口有序，可重复　　　　

　　　　　　ArrayList

　　　　　　优点: 底层数据结构是数组，查询快，增删慢

　　　　　　缺点: 线程不安全，效率高

　　　　　　LinkedList

　　　　　　优点: 底层数据结构是链表，查询慢，增删快

　　　　　　缺点: 线程不安全，效率高

　　　　　 Vector

　　　　　　优点: 底层数据结构是数组，查询快，增删慢

　　　　　　缺点: 线程安全，效率低

　　　 ——Set 无序，唯一

　　　　　　HashSet

　　　　　　底层数据结构是哈希表。(无序,唯一)

　　　　　　如何来保证元素唯一性?

　　　　　　答：依赖两个方法：hashCode()和equals()

　　　　　 LinkedHashSet

　　　　　　底层数据结构是链表和哈希表 (FIFO插入有序，且唯一)

　　　　　　原因如下两点：

　　　　　　答：1.由链表保证元素有序

　　　　　　　　2.由哈希表保证元素唯一

　　　　　　TreeSet

　　　　　　底层数据结构是红黑树。(唯一，且有序)

　　　　　　1. 如何保证元素排序的呢?

　　　　　　答：1.自然排序

　　　　　　　　2.比较器排序

　　　　　　2.如何保证元素唯一性的呢?

　　　　　　答：根据比较的返回值是否是0来决定

针对于Collection集合我们到底如何使用呢?（重点掌握）

　　唯一吗?

　　　　是：Set

　　　　　　排序吗?

　　　　　　　　是：TreeSet或LinkedHashSet
　　　　　　　　　　否：HashSet
　　　　　　　　　　如果你知道是Set，但是不知道是哪个Set，就用HashSet。

--------------------------------------------------------------------------------------

　　　　否：List

　　　　　　要安全吗?

　　　　　　　　是：Vector
　　　　　　　　　　否：ArrayList或者LinkedList

　　　　　　　　　　查询多：ArrayList
　　　　　　　　　　　　增删多：LinkedList

如果你知道是List，但是不知道是哪个List，就用ArrayList。如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。

　　Map接口：

　　　　　　Map接口有三个重要的实现类，分别是 HashMap、LinkedHashMap、Hashtable

　　　　　　1、TreeMap是有序的，HashMap和Hashtable是无序的。

　　　　　　2、Hashtable的方法是同步的，底层源码方法有（synchronized）这是两者主要区别。

　　　　　　这就意味着：

　　　　　　3、Hashtable是线程安全，HashMap是非线程安全。

　　　　　　4、HashMap效率较高，Hashtable效率较低.

重点问题重点分析

(一)、TreeSet，LinkedHashSet and HashSet 的区别

1.介绍

TreeSet，LinkedHashSet and HashSet 在Java中都是实现Set的数据结构

1.TreeSet的主要功能用于排序

2.LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)

3.HashSet只是通用的存储数据的集合

2.相同点

重复元素：因为三者都实现Set interface，所以三者都不包含重复元素.

线程安全：三者都不是线程安全的，如果要使用线程安全可以Collections.synchronizedSet()

3.不同点

性能和速度：HashSet插入数据最快，其次LinkHashSet，最慢的是TreeSet因为内部实现排序。

排序：HashSet不保证有序，LinkHashSet保证FIFO即按插入顺序排序，TreeSet安装内部实现排序，也可以自定义排序规则。

Null：HashSet和LinkHashSet允许存在null数据，但是TreeSet中插入null数据时会报NullPointerException异常。

4.不多说了上代码进行比较！

package com.jia.set;

import java.util.Arrays;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.TreeSet;

public class SetDemo {

    public static void main(String args[]) {

        HashSet<String> hashSet = new HashSet<>();

        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();

        TreeSet<String> treeSet = new TreeSet<>();

        for (String data : Arrays.asList("B", "A", "D", "C", "E")) {

            hashSet.add(data);

            linkedHashSet.add(data);

            treeSet.add(data);

        }

        // 不保证有序

        System.out.println("HashSet排序 :" + hashSet);

        // FIFO保证安装插入顺序排序

        System.out.println("LinkedHashSet插入顺序排序 :" + linkedHashSet);

        // 内部实现排序

        System.out.println("TreeSet内部排序 :" + treeSet);

    }

}

运行结果：

HashSet排序 :[A, B, C, D, E]

LinkedHashSet插入顺序排序 :[B, A, D, C, E]

TreeSet内部排序 :[A, B, C, D, E]

(二)、TreeSet的两种排序方式比较

1.排序的引入 (以基本数据类型的排序为例)　

package com.jia.set;

import java.util.TreeSet;

public class TreeSetDemo {

    public static void main(String[] args) {

        // 创建集合对象

        // 自然顺序进行排序

        TreeSet<Integer> treeSet = new TreeSet<Integer>();

        // 创建元素并添加

        // 3,6,9,12,15,18,21,22,30

        treeSet.add(3);

        treeSet.add(6);

        treeSet.add(9);

        treeSet.add(12);

        treeSet.add(15);

        treeSet.add(18);

        treeSet.add(21);

        treeSet.add(22);

        treeSet.add(30);

        // 遍历结果

        for (Integer data : treeSet) {

            System.out.println("TreeSet --> "+data);

        }

    }

}

运行结果：

TreeSet --> 3

TreeSet --> 6

TreeSet --> 9

TreeSet --> 12

TreeSet --> 15

TreeSet --> 18

TreeSet --> 21

TreeSet --> 22

TreeSet --> 30

2.如果是引用数据类型来说，比如自定义对象，又该如何排序呢?

比如创建一个学生类：

package com.jia.set;

//学生类

public class Student {

    private Integer id;

    private String name;

    public Student() {

    }

    public Student(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "Student{" +

                "id=" + id +

                ", name='" + name + '\'' +

                '}';

    }

}

测试类：

package com.jia.set;

import java.util.TreeSet;

public class StudentTreeSetDemo {

    public static void main(String[] args) {

        TreeSet<Student> treeSet = new TreeSet<Student>();

        //创建元素对象

        Student s1=new Student(1,"张三");

        Student s2=new Student(2,"李四");

        Student s3=new Student(3,"王五");

        Student s4=new Student(4,"赵六");

        Student s5=new Student(5,"陈七");

        Student s6=new Student(6,"杨八");

        //将元素对象添加到集合对象中

        treeSet.add(s1);

        treeSet.add(s2);

        treeSet.add(s3);

        treeSet.add(s4);

        treeSet.add(s5);

        treeSet.add(s6);

        //遍历结果

        for (Student student : treeSet) {

            System.out.println(student.getId()+"--->"+student.getName());

        }

    }

}

结果报错：

Exception in thread "main" java.lang.ClassCastException: com.jia.set.Student cannot be cast to java.lang.Comparable

    at java.util.TreeMap.compare(TreeMap.java:1294)

    at java.util.TreeMap.put(TreeMap.java:538)

    at java.util.TreeSet.add(TreeSet.java:255)

    at com.jia.set.StudentTreeSetDemo.main(StudentTreeSetDemo.java:20)
原因分析：
由于不知道该安照那一中排序方式排序，所以会报错。
解决方法：
1.自然排序
2.比较器排序

（1）自然排序

自然排序要进行一下操作：

1.Student类中实现Comparable接口

2.重写Comparable接口中的Comparable()方法

public int compareTo(T o); 比较此对象与指定对象的顺序。

package com.jia.set;

//学生类

public class Student implements Comparable<Student> {

    private Integer id;

    private String name;

    public Student() {

    }

    public Student(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "Student{" +

                "id=" + id +

                ", name='" + name + '\'' +

                '}';

    }

    @Override

    public int compareTo(Student s) {

        //return -1; //-1表示放在红黑树的左边,即逆序输出

        //return 1;  //1表示放在红黑树的右边，即顺序输出

        //return o;  //表示元素相同，仅存放第一个元素

        //主要条件 姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树

        int num = this.name.length()-s.name.length();

        //姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。

        //如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。

        //如果这两个字符串相等，则结果为 0

        int num1 = num==0?this.name.compareTo(s.name):num;

        //姓名的长度和内容相同，不代表id值相同，所以还要判断id

        int num2=num1==0?this.id-s.id:num1;

        return num2;

    }

}

运行结果：

1--->张三

2--->李四

6--->杨八

3--->王五

4--->赵六

5--->陈七

（2）比较器排序

步骤：1.单独创建一个比较类，以ComparatorTest为例，并且让其继承Comparator接口