1. 程式人生 > >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,它根據指定比較器進行排序。
1
測試類:

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