Java集合中List,Set以及Map等集合體系詳解(史上最全)

轉載請註明出處:Java集合中List,Set以及Map等集合體系詳解(史上最全)

概述:

• List , Set, Map都是介面，前兩個繼承至Collection介面，Map為獨立介面
• Set下有HashSet，LinkedHashSet，TreeSet
• List下有ArrayList，Vector，LinkedList
• Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
• Collection介面下還有個Queue介面，有PriorityQueue類

注意:

• Queue介面與List、Set同一級別，都是繼承了Collection介面。
  看圖你會發現,LinkedList既可以實現Queue介面,也可以實現List介面.只不過呢, LinkedList實現了Queue介面。Queue介面窄化了對LinkedList的方法的訪問許可權（即在方法中的引數型別如果是Queue時，就完全只能訪問Queue介面所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法），以使得只有恰當的方法才可以使用。

• SortedSet是個介面，它裡面的（只有TreeSet這一個實現可用）中的元素一定是有序的。

總結:

Connection介面:

— List 有序,可重複

• ArrayList
  優點: 底層資料結構是陣列，查詢快，增刪慢。
  缺點: 執行緒不安全，效率高
• Vector
  優點: 底層資料結構是陣列，查詢快，增刪慢。
  缺點: 執行緒安全，效率低
• LinkedList
  優點: 底層資料結構是連結串列，查詢慢，增刪快。
  缺點: 執行緒不安全，效率高

—Set 無序,唯一

• HashSet
  底層資料結構是雜湊表。(無序,唯一)
  如何來保證元素唯一性?
  1.依賴兩個方法：hashCode()和equals()

• LinkedHashSet
  底層資料結構是連結串列和雜湊表。(FIFO插入有序,唯一)
  1.由連結串列保證元素有序
  2.由雜湊表保證元素唯一

• TreeSet
  底層資料結構是紅黑樹。(唯一，有序)
  1. 如何保證元素排序的呢?
  自然排序
  比較器排序
  2.如何保證元素唯一性的呢?
  根據比較的返回值是否是0來決定

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

唯一嗎?

是：Set

排序嗎?

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

否：List

要安全嗎?

是：Vector
否：ArrayList或者LinkedList

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

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

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

Map介面:

上圖:

Map介面有三個比較重要的實現類，分別是HashMap、TreeMap和HashTable。

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

這就意味著:

• Hashtable是執行緒安全的，HashMap不是執行緒安全的。
• HashMap效率較高，Hashtable效率較低。
  如果對同步性或與遺留程式碼的相容性沒有任何要求，建議使用HashMap。 檢視Hashtable的原始碼就可以發現，除建構函式外，Hashtable的所有 public 方法宣告中都有 synchronized關鍵字，而HashMap的原始碼中則沒有。
• Hashtable不允許null值，HashMap允許null值（key和value都允許）
• 父類不同：Hashtable的父類是Dictionary，HashMap的父類是AbstractMap

重點問題重點分析:

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

1. 介紹

• TreeSet, LinkedHashSet and HashSet 在java中都是實現Set的資料結構

• TreeSet的主要功能用於排序
• LinkedHashSet的主要功能用於保證FIFO即有序的集合(先進先出)
• HashSet只是通用的儲存資料的集合

2. 相同點

• Duplicates elements: 因為三者都實現Set interface，所以三者都不包含duplicate elements
• Thread safety: 三者都不是執行緒安全的，如果要使用執行緒安全可以Collections.synchronizedSet()

3. 不同點

• Performance and Speed: HashSet插入資料最快，其次LinkHashSet，最慢的是TreeSet因為內部實現排序

• Ordering: HashSet不保證有序，LinkHashSet保證FIFO即按插入順序排序，TreeSet安裝內部實現排序，也可以自定義排序規則
• null:HashSet和LinkHashSet允許存在null資料，但是TreeSet中插入null資料時會報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);

        //內部實現排序
        System.out.println("Order of objects in TreeSet :" + treeSet);


    }

•  

執行結果:
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.排序的引入(以基本資料型別的排序為例)

由於TreeSet可以實現對元素按照某種規則進行排序，例如下面的例子

public class MyClass {

    public static void main(String[] args) {
        // 建立集合物件
        // 自然順序進行排序
        TreeSet<Integer> ts = new TreeSet<Integer>();

        // 建立元素並新增
        // 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);
        }
    }
}

•  

執行結果:
17
18
19
20
22
23
24

2.如果是引用資料型別呢,比如自定義物件,又該如何排序呢?

測試類:

public class MyClass {
    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<Student>();
        //建立元素物件
        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;
    }
}

•  

結果報錯:

原因分析：
由於不知道該安照那一中排序方式排序，所以會報錯。
解決方法：
1.自然排序
2.比較器排序

(1).自然排序

自然排序要進行一下操作：
1.Student類中實現 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;  //表示元素相同，僅存放第一個元素
        //主要條件 姓名的長度,如果姓名長度小的就放在左子樹，否則放在右子樹
        int num=this.name.length()-s.name.length();
        //姓名的長度相同，不代表內容相同,如果按字典順序此 String 物件位於引數字串之前，則比較結果為一個負整數。
        //如果按字典順序此 String 物件位於引數字串之後，則比較結果為一個正整數。
        //如果這兩個字串相等，則結果為 0
        int num1=num==0?this.name.compareTo(s.name):num;
        //姓名的長度和內容相同，不代表年齡相同，所以還要判斷年齡
        int num2=num1==0?this.age-s.age:num1;
        return num2;
    }
}

•  

執行結果:

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

(2).比較器排序

比較器排序步驟：
1.單獨建立一個比較類，這裡以MyComparator為例，並且要讓其繼承Comparator介面
2.重寫Comparator介面中的Compare方法

compare(T o1,T o2)      比較用來排序的兩個引數。

•  

3.在主類中使用下面的 構造方法

TreeSet(Comparator<? superE> comparator)
          構造一個新的空 TreeSet，它根據指定比較器進行排序。

•  

測試類:

public class MyClass {

    public static void main(String[] args) {
        //建立集合物件
        //TreeSet(Comparator<? super E> comparator) 構造一個新的空 TreeSet，它根據指定比較器進行排序。
        TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());

        //建立元素物件
        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();
        // 姓名內容
        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
        // 年齡
        int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
        return num3;
    }

}

•  

執行結果:

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) {
       //數值大小比較
        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);
    }

}

執行結果:

HashSet: 1544313
TreeSet: 2066049
LinkedHashSet: 629826
雖然測試不夠準確,但能反映得出，TreeSet要慢得多,因為它是有序的。

好了,至此完結.小夥伴有問題的話,請留言

參考文章:
HashSet、TreeSet和LinkedHashSet的使用區別
Collection集合總結
HashMap、TreeMap和HashTable的區別