List、Set集合系列之剖析HashSet存儲原理（HashMap底層）

時間  2019-11-07
標籤 list set 集合 系列 剖析 hashset 存儲 原理 hashmap 底層 欄目 快樂工作 简体版
原文   原文鏈接

前言javascript

在以前的博客文章中已經介紹了Collection接口使用，本篇將介紹Collection接口中的子類的用法，至於爲啥要講它的子類這種小白問題就不要問我了。啥？有小白在看我寫的文章...很差意思很差意思，原諒我剛纔說的話，請容許博主我從新組織一下語言...咳咳，至於爲啥要講Collection接口的子類呢？小白童鞋啊，Collection接口他是接口哇，接口的目的是啥？就是定義一套規範，沒有具體類去實現接口，接口就毫無心義了！小白童鞋你何什左咩鴨。java

還有一點就是若是對Collection接口還不熟悉的小白童鞋強烈建議先去了解Collection接口以後再看這篇文章，否則只會事倍功半！好吧，我就知道就是博主我強烈建議過了確定還有小白童鞋不去找，沒事，博主沒別的目的，就是想讓小白童鞋好好學java，因此我已經準備好了下面這篇文章~點擊藍色字體便可進入~Collection集合以及Iterator迭代器實現原理程序員

@[toc]數組

List接口

接下來，咱們一塊兒學習Collection中的經常使用兩個子類java.util.List集合、java.util.Set集合。數據結構

1.1 List接口介紹

java.util.List接口繼承自Collection接口，在List集合元素可重複、元素有序。全部的元素是以一種線性方式進行存儲的，在程序中能夠經過索引來訪問集合中的指定元素，並且元素的存入順序和取出順序一致。ide

List接口特色分析：函數

  1. 元素存取有序：例如，存元素的順序是「我」、「是」、「佩」、「奇」，那麼集合中，元素的存儲就是按照「我」、「是」、「佩」、「奇」的順序完成的。
  2. 帶有索引的集合：與數組的索引是一個道理
  3. 元素重複：經過元素的equals方法，來比較是否爲重複的元素。

1.2 List接口中經常使用方法

List做爲Collection集合的子接口，不但繼承了Collection接口中的所有方法，還有一些根據元素索引來操做集合的特有方法，以下：源碼分析

public void add(int index, E element): 將指定的元素，添加到該集合中的指定位置上。- public E get(int index):返回集合中指定位置的元素。 public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。 public E set(int index, E element):用指定元素替換集合中指定位置的元素,返回值的更新前的元素。性能

List集合特有的方法都是跟索引相關，代碼以下：學習

public class ListDemo {
    public static void main(String[] args) {
		// 建立List集合對象
    	List<String> list = new ArrayList<String>();
    	
    	// 往 尾部添加 指定元素
    	list.add("安琪拉屎");
    	list.add("劉備胎");
    	list.add("廉頗婦");
    	
    	System.out.println(list);
    	// add(int index,String s) 往指定位置添加
    	list.add(1,"豬腳亮");
    	
    	System.out.println(list);
    	// String remove(int index) 刪除指定位置元素 返回被刪除元素
    	// 刪除索引位置爲2的元素 
    	System.out.println("刪除索引位置爲2的元素");
    	System.out.println(list.remove(2));
    	
    	System.out.println(list);
    	
    	// String set(int index,String s)
    	// 在指定位置 進行 元素替代（改） 
    	// 修改指定位置元素
    	list.set(0, "東皇太二");
    	System.out.println(list);
    	
    	// String get(int index) 獲取指定位置元素
    	
    	// 跟size() 方法一塊兒用 來 遍歷的 
    	for(int i = 0;i<list.size();i++){
    		System.out.println(list.get(i));
    	}
    	//還可使用加強for
    	for (String string : list) {
			System.out.println(string);
		}  	
	}
}
複製代碼

List的子類

2.1 ArrayList集合

java.util.ArrayList集合數據存儲的結構是數組結構。元素增刪慢，查找快，因爲平常開發中使用最多的功能爲查詢數據、遍歷數據，因此ArrayList是最經常使用的集合。

2.2 LinkedList集合

java.util.LinkedList集合數據存儲的結構是鏈表結構。元素增刪快，查找慢的集合。

LinkedList是一個雙向鏈表，那麼雙向鏈表是什麼樣子的呢？

在這裏插入圖片描述

實際開發中對一個集合元素的添加與刪除常常涉及到首尾操做，而LinkedList提供了大量首尾操做的方法。下面這些方法咱們做爲瞭解便可：

  • public void addFirst(E e):將指定元素插入此列表的開頭。
  • public void addLast(E e):將指定元素添加到此列表的結尾。
  • public E getFirst():返回此列表的第一個元素。
  • public E getLast():返回此列表的最後一個元素。
  • public E removeFirst():移除並返回此列表的第一個元素。
  • public E removeLast():移除並返回此列表的最後一個元素。
  • public E pop():今後列表所表示的堆棧處彈出一個元素。
  • public void push(E e):將元素推入此列表所表示的堆棧。
  • public boolean isEmpty()：若是列表不包含元素，則返回true。

LinkedList是List的子類，List中的方法LinkedList都是可使用，這裏就不作詳細介紹，咱們只須要了解LinkedList的特有方法便可。在開發時，LinkedList集合也能夠做爲堆棧，隊列的結構使用。（瞭解便可）

方法代碼以下：

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        //添加元素
        link.addFirst("大喬");
        link.addFirst("小橋");
        link.addFirst("老喬");
        System.out.println(link);
        // 獲取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        // 刪除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());

        while (!link.isEmpty()) { //判斷集合是否爲空
            System.out.println(link.pop()); //彈出集合中的棧頂元素
        }

        System.out.println(link);
    }
}
複製代碼

好了，到這裏，list集合就先告一段落。

Set接口

3.1 Set接口介紹

java.util.Set接口和java.util.List接口同樣，一樣繼承自Collection接口，它與Collection接口中的方法基本一致，並無對Collection接口進行功能上的擴充，只是比Collection接口更加嚴格了。與List接口不一樣的是，Set接口中元素無序且不重複，恰好全與list相反，set會以某種規則保證存入的元素不出現重複。

Set集合有多個子類，這裏咱們介紹其中的java.util.HashSet、java.util.LinkedHashSet這兩個集合。

Set集合取出元素的方式能夠採用：迭代器、加強for。

Set接口子類

4.1 HashSet集合介紹

java.util.HashSet是Set接口的一個實現類，它所存儲的元素是不可重複、無序(即存取順序不一致)。java.util.HashSet底層的實現實際上是一個java.util.HashMap支持。

HashSet是根據對象的哈希值來肯定元素在集合中的存儲位置，所以具備良好的存取和查找性能。保證元素惟一性的方式依賴於：hashCode與equals方法。

咱們先來使用一下Set集合存儲，看下現象，再進行原理的講解:

public class HashSetDemo {
    public static void main(String[] args) {
        //建立 Set集合
        HashSet<String>  set = new HashSet<String>();

        //添加元素
        set.add(new String("安琪拉屎"));
        set.add("劉備胎");
        set.add("豬八戒菸"); 
        set.add("安琪拉屎");  
        //遍歷
        for (String name : set) {
            System.out.println(name);
        }
    }
}
複製代碼

輸出結果以下，說明集合中不能存儲重複元素：

安琪拉屎
劉備胎
豬八戒菸
複製代碼

根據結果咱們發現字符串 "安琪拉屎" 只存儲了一個，也就是說重複的元素set集合不存儲。

4.2 HashSet集合存儲數據的結構（哈希表）

什麼是哈希表呢？

在JDK1.8以前，哈希表底層採用數組+鏈表實現，即便用鏈表處理衝突，同一hash值的鏈表都存儲在一個鏈表裏。可是當位於一個桶中的元素較多，即hash值相等的元素較多時，經過key值依次查找的效率較低。而JDK1.8中，哈希表存儲採用數組+鏈表+紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換爲紅黑樹，這樣大大減小了查找時間。

簡單的來講，哈希表是由數組+鏈表+紅黑樹（JDK1.8增長了紅黑樹部分）實現的，以下圖所示。

在這裏插入圖片描述
看到這張圖就有童鞋要問了，這個是怎麼存儲的呢？看下圖就明白了

在這裏插入圖片描述
總而言之， JDK1.8引入紅黑樹大程度優化了HashMap的性能，那麼對於咱們來說保證HashSet集合元素的惟一，其實就是根據對象的hashCode和equals方法來決定的。若是咱們往集合中存放自定義的對象，那麼保證其惟一，就必須複寫hashCode和equals方法創建屬於當前對象的比較方式。

至於數據結構關於數組以及鏈表我以前寫過，爲了方便各位閱讀，我就貼在下面了

【數據結構01】淺談數組

【數據結構03】淺談鏈表

啥？還要看紅黑樹？額...暫時還沒寫，若是不是特別急着看博主就日後推一點寫，~畢竟忙嘛~ 實在急着看博主儘可能抽空寫一篇出來...

4.3源碼分析

QnQ

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable {  
    static final long serialVersionUID = -5024744406713321676L;  
 
    // 底層使用HashMap來保存HashSet中全部元素。 
    private transient HashMap<E,Object> map;  
 
    // 定義一個虛擬的Object對象做爲HashMap的value，將此對象定義爲static final。 
    private static final Object PRESENT = new Object();  
 
    /** * 默認的無參構造器，構造一個空的HashSet。 * * 實際底層會初始化一個空的HashMap，並使用默認初始容量爲16和加載因子0.75。 */  
    public HashSet() {  
    map = new HashMap<E,Object>();  
    }  
 
    /** * 構造一個包含指定collection中的元素的新set。 * * 實際底層使用默認的加載因子0.75和足以包含指定 * collection中全部元素的初始容量來建立一個HashMap。 * @param c 其中的元素將存放在此set中的collection。 */  
    public HashSet(Collection<? extends E> c) {  
    map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));  
    addAll(c);  
    }  
 
    /** * 以指定的initialCapacity和loadFactor構造一個空的HashSet。 * * 實際底層以相應的參數構造一個空的HashMap。 * @param initialCapacity 初始容量。 * @param loadFactor 加載因子。 */  
    public HashSet(int initialCapacity, float loadFactor) {  
    map = new HashMap<E,Object>(initialCapacity, loadFactor);  
    }  
 
    /** * 以指定的initialCapacity構造一個空的HashSet。 * * 實際底層以相應的參數及加載因子loadFactor爲0.75構造一個空的HashMap。 * @param initialCapacity 初始容量。 */  
    public HashSet(int initialCapacity) {  
    map = new HashMap<E,Object>(initialCapacity);  
    }  
 
    /** * 以指定的initialCapacity和loadFactor構造一個新的空連接哈希集合。 * 此構造函數爲包訪問權限，不對外公開，實際只是是對LinkedHashSet的支持。 * * 實際底層會以指定的參數構造一個空LinkedHashMap實例來實現。 * @param initialCapacity 初始容量。 * @param loadFactor 加載因子。 * @param dummy 標記。 */  
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
    }  
 
    /** * 返回對此set中元素進行迭代的迭代器。返回元素的順序並非特定的。 * * 底層實際調用底層HashMap的keySet來返回全部的key。 * 可見HashSet中的元素，只是存放在了底層HashMap的key上， * value使用一個static final的Object對象標識。 * @return 對此set中元素進行迭代的Iterator。 */  
    public Iterator<E> iterator() {  
    return map.keySet().iterator();  
    }  
 
    /** * 返回此set中的元素的數量（set的容量）。 * * 底層實際調用HashMap的size()方法返回Entry的數量，就獲得該Set中元素的個數。 * @return 此set中的元素的數量（set的容量）。 */  
    public int size() {  
    return map.size();  
    }  
 
    /** * 若是此set不包含任何元素，則返回true。 * * 底層實際調用HashMap的isEmpty()判斷該HashSet是否爲空。 * @return 若是此set不包含任何元素，則返回true。 */  
    public boolean isEmpty() {  
    return map.isEmpty();  
    }  
 
    /** * 若是此set包含指定元素，則返回true。 * 更確切地講，當且僅當此set包含一個知足(o==null ? e==null : o.equals(e)) * 的e元素時，返回true。 * * 底層實際調用HashMap的containsKey判斷是否包含指定key。 * @param o 在此set中的存在已獲得測試的元素。 * @return 若是此set包含指定元素，則返回true。 */  
    public boolean contains(Object o) {  
    return map.containsKey(o);  
    }  
 
    /** * 若是此set中還沒有包含指定元素，則添加指定元素。 * 更確切地講，若是此 set 沒有包含知足(e==null ? e2==null : e.equals(e2)) * 的元素e2，則向此set 添加指定的元素e。 * 若是此set已包含該元素，則該調用不更改set並返回false。 * * 底層實際將將該元素做爲key放入HashMap。 * 因爲HashMap的put()方法添加key-value對時，當新放入HashMap的Entry中key * 與集合中原有Entry的key相同（hashCode()返回值相等，經過equals比較也返回true）， * 新添加的Entry的value會將覆蓋原來Entry的value，但key不會有任何改變， * 所以若是向HashSet中添加一個已經存在的元素時，新添加的集合元素將不會被放入HashMap中， * 原來的元素也不會有任何改變，這也就知足了Set中元素不重複的特性。 * @param e 將添加到此set中的元素。 * @return 若是此set還沒有包含指定元素，則返回true。 */  
    public boolean add(E e) {  
    return map.put(e, PRESENT)==null;  
    }  
 
    /** * 若是指定元素存在於此set中，則將其移除。 * 更確切地講，若是此set包含一個知足(o==null ? e==null : o.equals(e))的元素e， * 則將其移除。若是此set已包含該元素，則返回true * （或者：若是此set因調用而發生更改，則返回true）。（一旦調用返回，則此set再也不包含該元素）。 * * 底層實際調用HashMap的remove方法刪除指定Entry。 * @param o 若是存在於此set中則須要將其移除的對象。 * @return 若是set包含指定元素，則返回true。 */  
    public boolean remove(Object o) {  
    return map.remove(o)==PRESENT;  
    }  
 
    /** * 今後set中移除全部元素。此調用返回後，該set將爲空。 * * 底層實際調用HashMap的clear方法清空Entry中全部元素。 */  
    public void clear() {  
    map.clear();  
    }  
 
    /** * 返回此HashSet實例的淺表副本：並無複製這些元素自己。 * * 底層實際調用HashMap的clone()方法，獲取HashMap的淺表副本，並設置到HashSet中。 */  
    public Object clone() {  
        try {  
            HashSet<E> newSet = (HashSet<E>) super.clone();  
            newSet.map = (HashMap<E, Object>) map.clone();  
            return newSet;  
        } catch (CloneNotSupportedException e) {  
            throw new InternalError();  
        }  
    }  
}  
複製代碼

說白了，HashSet就是限制了功能的HashMap，因此瞭解HashMap的實現原理，這個HashSet天然就通,對於HashSet中保存的對象，主要要正確重寫equals方法和hashCode方法，以保證放入Set對象的惟一性,雖然說是Set是對於重複的元素不放入，倒不如直接說是底層的Map直接把原值替代了（這個Set的put方法的返回值真有意思）。HashSet沒有提供get()方法，願意是同HashMap同樣，Set內部是無序的，只能經過迭代的方式得到。

4.4 HashSet存儲自定義類型元素

給HashSet中存放自定義類型元素時，須要重寫對象中的hashCode和equals方法，創建本身的比較方式，才能保證HashSet集合中的對象惟一

建立自定義Student類

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

    public Student() {
    }

    public Student(String name, int age) {
        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 boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
複製代碼
public class HashSetDemo2 {
    public static void main(String[] args) {
        //建立集合對象 該集合中存儲 Student類型對象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存儲 
        Student stu = new Student("程序員老王", 43);
        stuSet.add(stu);
        stuSet.add(new Student("程序員小王", 44));
        stuSet.add(new Student("程序員老王", 43));
        stuSet.add(new Student("程序員禿頭哥", 23));
        stuSet.add(stu);

        for (Student stud : stuSet) {
            System.out.println(stud);
        }
    }
}
執行結果：
Student [name=程序員小王, age=44]
Student [name=程序員老王, age=43]
Student [name=程序員禿頭哥, age=23]
複製代碼

4.5 LinkedHashSet

咱們知道HashSet保證元素惟一，但是元素存放進去是沒有順序的，那麼咱們要保證有序，怎麼辦呢？在HashSet下面有一個子類java.util.LinkedHashSet，它是鏈表和哈希表組合的一個數據存儲結構。

代碼以下:

public class LinkedHashSetDemo {
	public static void main(String[] args) {
		Set<String> set = new LinkedHashSet<String>();
		set.add("禿頭哥");
		set.add("地中海哥");
		set.add("平頭哥");
		set.add("假髮哥");
        Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
結果：
 禿頭哥
 地中海哥
 平頭哥
 假髮哥
複製代碼

最後，歡迎各位關注個人公衆號，一塊兒探討技術，嚮往技術，追求技術...

在這裏插入圖片描述
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程