概述:

• List , Set, Map都是接口，前兩個(gè)繼承至collection接口，Map為獨(dú)立接口
• Set下有HashSet,，LinkedHashSet,，TreeSet
• List下有ArrayList,，Vector,，LinkedList
• Map下有Hashtable,，LinkedHashMap,，HashMap,，TreeMap
• collection接口下還有個(gè)Queue接口，有PriorityQueue類

注意:

• Queue接口與List,、Set同一級別,，都是繼承了collection接口。
  看圖你會(huì)發(fā)現(xiàn),LinkedList既可以實(shí)現(xiàn)Queue接口,也可以實(shí)現(xiàn)List接口.只不過呢, LinkedList實(shí)現(xiàn)了Queue接口,。Queue接口窄化了對LinkedList的方法的訪問權(quán)限（即在方法中的參數(shù)類型如果是Queue時(shí),，就完全只能訪問Queue接口所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法）,，以使得只有恰當(dāng)?shù)姆椒ú趴梢允褂谩?/p>

• SortedSet是個(gè)接口,，它里面的（只有TreeSet這一個(gè)實(shí)現(xiàn)可用）中的元素一定是有序的。

總結(jié):

connection接口(注意首字母小寫):

— List 有序,可重復(fù)

• ArrayList
  優(yōu)點(diǎn): 底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組,，查詢快,，增刪慢,。
  缺點(diǎn): 線程不安全，效率高
• Vector
  優(yōu)點(diǎn): 底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組,，查詢快,，增刪慢。
  缺點(diǎn): 線程安全,，效率低
• LinkedList
  優(yōu)點(diǎn): 底層數(shù)據(jù)結(jié)構(gòu)是鏈表,，查詢慢，增刪快,。
  缺點(diǎn): 線程不安全,，效率高

—Set 無序,唯一

• HashSet
  底層數(shù)據(jù)結(jié)構(gòu)是哈希表。(無序,唯一)
  如何來保證元素唯一性?
  1.依賴兩個(gè)方法：hashCode()和equals()

• LinkedHashSet
  底層數(shù)據(jù)結(jié)構(gòu)是鏈表和哈希表,。(FIFO插入有序,唯一)
  1.由鏈表保證元素有序
  2.由哈希表保證元素唯一

• TreeSet
  底層數(shù)據(jù)結(jié)構(gòu)是紅黑樹,。(唯一，有序)
  1. 如何保證元素排序的呢?
  自然排序
  比較器排序
  2.如何保證元素唯一性的呢?
  根據(jù)比較的返回值是否是0來決定

針對collection集合我們到底使用誰呢?(掌握)

唯一嗎?

是：Set

排序嗎?

是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set,，但是不知道是哪個(gè)Set,，就用HashSet。

否：List

要安全嗎?

是：Vector
否：ArrayList或者LinkedList

查詢多：ArrayList
增刪多：LinkedList
如果你知道是List,，但是不知道是哪個(gè)List,，就用ArrayList。

如果你知道是collection集合,，但是不知道使用誰,，就用ArrayList。
如果你知道用集合,，就用ArrayList,。

說完了collection,來簡單說一下Map.

Map接口:

上圖:

Map接口有三個(gè)比較重要的實(shí)現(xiàn)類，分別是HashMap,、TreeMap和HashTable,。

• TreeMap是有序的，HashMap和HashTable是無序的,。
• Hashtable的方法是同步的,，HashMap的方法不是同步的。這是兩者最主要的區(qū)別,。

這就意味著:

• Hashtable是線程安全的,，HashMap不是線程安全的。
• HashMap效率較高,，Hashtable效率較低,。
  如果對同步性或與遺留代碼的兼容性沒有任何要求，建議使用HashMap,。 查看Hashtable的源代碼就可以發(fā)現(xiàn),，除構(gòu)造函數(shù)外,，Hashtable的所有 public 方法聲明中都有 synchronized關(guān)鍵字，而HashMap的源碼中則沒有,。
• Hashtable不允許null值,，HashMap允許null值（key和value都允許）
• 父類不同：Hashtable的父類是Dictionary，HashMap的父類是AbstractMap

重點(diǎn)問題重點(diǎn)分析:

(一).TreeSet, LinkedHashSet and HashSet 的區(qū)別

1. 介紹

• TreeSet, LinkedHashSet and HashSet 在java中都是實(shí)現(xiàn)Set的數(shù)據(jù)結(jié)構(gòu)

• TreeSet的主要功能用于排序
• LinkedHashSet的主要功能用于保證FIFO即有序的集合(先進(jìn)先出)
• HashSet只是通用的存儲(chǔ)數(shù)據(jù)的集合

2. 相同點(diǎn)

• Duplicates elements: 因?yàn)槿叨紝?shí)現(xiàn)Set interface,，所以三者都不包含duplicate elements
• Thread safety: 三者都不是線程安全的,，如果要使用線程安全可以collections.synchronizedSet()

3. 不同點(diǎn)

• Performance and Speed: HashSet插入數(shù)據(jù)最快，其次LinkHashSet,，最慢的是TreeSet因?yàn)閮?nèi)部實(shí)現(xiàn)排序

• Ordering: HashSet不保證有序,，LinkHashSet保證FIFO即按插入順序排序，TreeSet安裝內(nèi)部實(shí)現(xiàn)排序,，也可以自定義排序規(guī)則
• null:HashSet和LinkHashSet允許存在null數(shù)據(jù),，但是TreeSet中插入null數(shù)據(jù)時(shí)會(huì)報(bào)NullPointerException

4. 代碼比較

  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", "E", "D", "C", "A")) {
            hashSet.add(data);
            linkedHashSet.add(data);
            treeSet.add(data);
        }

        //不保證有序
        System.out.println("Ordering in HashSet :" + hashSet);

        //FIFO保證安裝插入順序排序
        System.out.println("Order of element in LinkedHashSet :" + linkedHashSet);

        //內(nèi)部實(shí)現(xiàn)排序
        System.out.println("Order of objects in TreeSet :" + treeSet);


    }

運(yùn)行結(jié)果:
Ordering in HashSet :[A, B, C, D, E] (無順序)
Order of element in LinkedHashSet :[B, E, D, C, A] (FIFO插入有序)
Order of objects in TreeSet :[A, B, C, D, E] (排序)

(二).TreeSet的兩種排序方式比較

1.排序的引入(以基本數(shù)據(jù)類型的排序?yàn)槔?

由于TreeSet可以實(shí)現(xiàn)對元素按照某種規(guī)則進(jìn)行排序，例如下面的例子

public class MyClass {

    public static void main(String[] args) {
        // 創(chuàng)建集合對象
        // 自然順序進(jìn)行排序
        TreeSet<Integer> ts = new TreeSet<Integer>();

        // 創(chuàng)建元素并添加
        // 20,18,23,22,17,24,19,18,24
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);

        // 遍歷
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

運(yùn)行結(jié)果:
17
18
19
20
22
23
24

2.如果是引用數(shù)據(jù)類型呢,比如自定義對象,又該如何排序呢?

測試類:

public class MyClass {
    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<Student>();
        //創(chuàng)建元素對象
        Student s1=new Student("zhangsan",20);
        Student s2=new Student("lis",22);
        Student s3=new Student("wangwu",24);
        Student s4=new Student("chenliu",26);
        Student s5=new Student("zhangsan",22);
        Student s6=new Student("qianqi",24);

        //將元素對象添加到集合對象中
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍歷
        for(Student s:ts){
            System.out.println(s.getName()+"-----------"+s.getAge());
        }
    }
}

Student.java:

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

結(jié)果報(bào)錯(cuò):

原因分析：
由于不知道該安照那一中排序方式排序,，所以會(huì)報(bào)錯(cuò),。
解決方法：
1.自然排序
2.比較器排序

(1).自然排序

自然排序要進(jìn)行一下操作：
1.Student類中實(shí)現(xiàn) Comparable接口
2.重寫Comparable接口中的Compareto方法

compareTo(T o)  比較此對象與指定對象的順序。

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student s) {
        //return -1; //-1表示放在紅黑樹的左邊,即逆序輸出
        //return 1;  //1表示放在紅黑樹的右邊,，即順序輸出
        //return o;  //表示元素相同,，僅存放第一個(gè)元素
        //主要條件 姓名的長度,如果姓名長度小的就放在左子樹，否則放在右子樹
        int num=this.name.length()-s.name.length();
        //姓名的長度相同,，不代表內(nèi)容相同,如果按字典順序此 String 對象位于參數(shù)字符串之前，則比較結(jié)果為一個(gè)負(fù)整數(shù),。
        //如果按字典順序此 String 對象位于參數(shù)字符串之后,，則比較結(jié)果為一個(gè)正整數(shù)。
        //如果這兩個(gè)字符串相等,，則結(jié)果為 0
        int num1=num==0?this.name.compareTo(s.name):num;
        //姓名的長度和內(nèi)容相同,，不代表年齡相同，所以還要判斷年齡
        int num2=num1==0?this.age-s.age:num1;
        return num2;
    }
}

運(yùn)行結(jié)果:

lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22

(2).比較器排序

比較器排序步驟：
1.單獨(dú)創(chuàng)建一個(gè)比較類,，這里以MyComparator為例,，并且要讓其繼承Comparator接口
2.重寫Comparator接口中的Compare方法

compare(T o1,T o2)      比較用來排序的兩個(gè)參數(shù)。

3.在主類中使用下面的 構(gòu)造方法

TreeSet(Comparator<? superE> comparator)
          構(gòu)造一個(gè)新的空 TreeSet,，它根據(jù)指定比較器進(jìn)行排序,。

測試類:

public class MyClass {

    public static void main(String[] args) {
        //創(chuàng)建集合對象
        //TreeSet(Comparator<? super E> comparator) 構(gòu)造一個(gè)新的空 TreeSet，它根據(jù)指定比較器進(jìn)行排序,。
        TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());

        //創(chuàng)建元素對象
        Student s1=new Student("zhangsan",20);
        Student s2=new Student("lis",22);
        Student s3=new Student("wangwu",24);
        Student s4=new Student("chenliu",26);
        Student s5=new Student("zhangsan",22);
        Student s6=new Student("qianqi",24);

        //將元素對象添加到集合對象中
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍歷
        for(Student s:ts){
            System.out.println(s.getName()+"-----------"+s.getAge());
        }
    }
}

Student.java:

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

MyComparator類：

public class MyComparator implements Comparator<Student> {

    @Override
    public int compare(Student s1,Student s2) {
        // 姓名長度
        int num = s1.getName().length() - s2.getName().length();
        // 姓名內(nèi)容
        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
        // 年齡
        int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
        return num3;
    }

}

運(yùn)行結(jié)果:

lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22

(三). 性能測試

對象類:

class Dog implements Comparable<Dog> {
    int size;
    public Dog(int s) {
        size = s;
    }
    public String toString() {
        return size + "";
    }
    @Override
    public int compareTo(Dog o) {
       //數(shù)值大小比較
        return size - o.size;
    }
}

主類:

public class MyClass {

    public static void main(String[] args) {

        Random r = new Random();
        HashSet<Dog> hashSet = new HashSet<Dog>();
        TreeSet<Dog> treeSet = new TreeSet<Dog>();
        LinkedHashSet<Dog> linkedSet = new LinkedHashSet<Dog>();

        // start time
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            hashSet.add(new Dog(x));
        }

        // end time
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println("HashSet: " + duration);

        // start time
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            treeSet.add(new Dog(x));
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("TreeSet: " + duration);

        // start time
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            linkedSet.add(new Dog(x));
        }

        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("LinkedHashSet: " + duration);
    }

}

運(yùn)行結(jié)果:

HashSet: 1544313
TreeSet: 2066049
LinkedHashSet: 629826
雖然測試不夠準(zhǔn)確,但能反映得出,，TreeSet要慢得多,因?yàn)樗怯行虻摹?/p>

好了,至此完結(jié).小伙伴有問題的話,請留言

參考文章:
HashSet、TreeSet和LinkedHashSet的使用區(qū)別
collection集合總結(jié)
HashMap,、TreeMap和HashTable的區(qū)別