大量 cep 數組元素 自定義 println strong 異或運算 bug set接口

目錄介紹

  • 3.0.0.1 在arrayList中System.arraycopy()和Arrays.copyOf()方法區別聯系?System.arraycopy()和Arrays.copyOf()代碼說明?
  • 3.0.0.2 SparseArray基本介紹,相比HashMap為什麽性能會好?
  • 3.0.0.3 Arrays和Collections 對於sort的不同實現原理?說一說它們的區別……
  • 3.0.0.4 Java集合框架中有哪些類?都有什麽特點?Java集合的快速失敗機制 “fail-fast”?
  • 3.0.0.5 ArrayList,Vector和LinkList的區別,底層分別是怎麽實現的,存儲空間是如何擴容的?什麽是加載因子?
  • 3.0.0.6 如何理解ArrayList的擴容消耗?Arrays.asList方法後的List可以擴容嗎?ArrayList如何序列化?
  • 3.0.0.7 如何理解list集合讀寫機制和讀寫效率?什麽是CopyOnWriteArrayList,它與ArrayList有何不同?
  • 3.0.1.0 HashSet和TreeSet的區別?是如何保證唯一值的,底層怎麽做到的?
  • 3.0.1.5 HashMap和Hashtable的區別?HashMap在put、get元素的過程?體現了什麽數據結構?
  • 3.0.1.6 如何保證HashMap線程安全?底層怎麽實現的?HashMap是有序的嗎?如何實現有序?
  • 3.0.1.7 HashMap存儲兩個對象的hashcode相同會發生什麽?如果兩個鍵的hashcode相同,你如何獲取值對象?
  • 3.0.1.8 HashMap為什麽不直接使用hashCode()處理後的哈希值直接作為table的下標?
  • 3.0.1.9 為什麽HashMap中String、Integer這樣的包裝類適合作為K?為啥不用其他作key值?
  • 3.0.2.0 HashMap是如何擴容的?如何理解HashMap的大小超過了負載因子定義的容量?重新調整HashMap大小存在什麽問題嗎?

好消息

  • 博客筆記大匯總【15年10月到至今】,包括Java基礎及深入知識點,Android技術博客,Python學習筆記等等,還包括平時開發中遇到的bug匯總,當然也在工作之余收集了大量的面試題,長期更新維護並且修正,持續完善……開源的文件是markdown格式的!同時也開源了生活博客,從12年起,積累共計500篇[近100萬字],將會陸續發表到網上,轉載請註明出處,謝謝!
  • 鏈接地址:https://github.com/yangchong211/YCBlogs
  • 如果覺得好,可以star一下,謝謝!當然也歡迎提出建議,萬事起於忽微,量變引起質變!所有博客將陸續開源到GitHub!

3.0.0.1 在arrayList中System.arraycopy()和Arrays.copyOf()方法區別聯系?System.arraycopy()和Arrays.copyOf()代碼說明?

  • System.arraycopy()和Arrays.copyOf()方法區別?
    • 比如下面add(int index, E element)方法就很巧妙的用到了arraycopy()方法讓數組自己復制自己實現讓index開始之後的所有成員後移一個位置:
      /**
       * 在此列表中的指定位置插入指定的元素。 
       * 先調用 rangeCheckForAdd 對index進行界限檢查;然後調用 ensureCapacityInternal 方法保證capacity足夠大;
       * 再將從index開始之後的所有成員後移一個位置;將element插入index位置;最後size加1。
       */
      public void add(int index, E element) {
          rangeCheckForAdd(index);
          ensureCapacityInternal(size + 1); 
          //arraycopy()方法實現數組自己復制自己
          //elementData:源數組;index:源數組中的起始位置;elementData:目標數組;index + 1:目標數組中的起始位置; size - index:要復制的數組元素的數量;
          System.arraycopy(elementData, index, elementData, index + 1, size - index);
          elementData[index] = element;
          size++;
      }
      
    • 如toArray()方法中用到了copyOf()方法
      /**
       *以正確的順序(從第一個到最後一個元素)返回一個包含此列表中所有元素的數組。 
       *返回的數組將是“安全的”,因為該列表不保留對它的引用。 (換句話說,這個方法必須分配一個新的數組)。
       *因此,調用者可以自由地修改返回的數組。 此方法充當基於陣列和基於集合的API之間的橋梁。
       */
      public Object[] toArray() {
      //elementData:要復制的數組;size:要復制的長度
          return Arrays.copyOf(elementData, size);
      }
      
    • 兩者聯系與區別
      • 看了上面的兩者源代碼可以發現copyOf()內部調用了System.arraycopy()方法
      • 技術博客大總結
      • 區別:
        • 1.arraycopy()需要目標數組,將原數組拷貝到你自己定義的數組裏,而且可以選擇拷貝的起點和長度以及放入新數組中的位置
        • 2.copyOf()是系統自動在內部新建一個數組,並返回該數組。
  • System.arraycopy()和Arrays.copyOf()代碼說明?
    • 使用System.arraycopy()方法
      public static void main(String[] args) {
      	// TODO Auto-generated method stub
      	int[] a = new int[10];
      	a[0] = 0;
      	a[1] = 1;
      	a[2] = 2;
      	a[3] = 3;
      	System.arraycopy(a, 2, a, 3, 3);
      	a[2]=99;
      	for (int i = 0; i < a.length; i++) {
      		System.out.println(a[i]);
      	}
      }
      
      //結果:
      //0 1 99 2 3 0 0 0 0 0 
      
    • 使用Arrays.copyOf()方法。技術博客大總結
      public static void main(String[] args) {
      	int[] a = new int[3];
      	a[0] = 0;
      	a[1] = 1;
      	a[2] = 2;
      	int[] b = Arrays.copyOf(a, 10);
      	System.out.println("b.length"+b.length);
      	//結果:
          //10
      }
      
    • 得出結論
      • arraycopy() 需要目標數組,將原數組拷貝到你自己定義的數組裏或者原數組,而且可以選擇拷貝的起點和長度以及放入新數組中的位置 copyOf() 是系統自動在內部新建一個數組,並返回該數組。

3.0.0.2 SparseArray基本介紹,相比HashMap為什麽性能會好?

  • 位於android.util,Android 中的數據結構,針對移動端做了優化,在數據量比較少的情況下,性能會好過 HashMap,類似於 HashMap,key:int ,value:object 。
  • 1.key 和 value 采用數組進行存儲。存儲 key 的數組是 int 類型,不需要進行裝箱操作。提供了速度。
  • 2.采用二分查找法,在插入進行了排序,所以兩個數組是按照從小到大進行排序的。
  • 3.在查找的時候,進行二分查找,數據量少的情況下,速度比較快。

3.0.0.3 Arrays和Collections 對於sort的不同實現原理?說一說它們的區別……

  • 1、Arrays.sort()
    • 該算法是一個經過調優的快速排序,此算法在很多數據集上提供N*log(N)的性能,這導致其他快速排序會降低二次型性能。
  • 2、Collections.sort()
    • 該算法是一個經過修改的合並排序算法(其中,如果低子列表中的最高元素效益高子列表中的最低元素,則忽略合並)。此算法可提供保證的N*log(N)的性能,此實現將指定列表轉儲到一個數組中,然後再對數組進行排序,在重置數組中相應位置處每個元素的列表上進行叠代。
  • 它們的區別
    • 技術博客大總結

3.0.0.4 Java集合框架中有哪些類?都有什麽特點?Java集合的快速失敗機制 “fail-fast”?

  • 可將Java集合框架大致可分為Set、List、Queue 和Map四種體系
    • Set:代表無序、不可重復的集合,常見的類如HashSet、TreeSet
    • List:代表有序、可重復的集合,常見的類如動態數組ArrayList、雙向鏈表LinkedList、可變數組Vector
    • Map:代表具有映射關系的集合,常見的類如HashMap、LinkedHashMap、TreeMap
    • Queue:代表一種隊列集合
  • Java集合的快速失敗機制 “fail-fast”
    • 技術博客大總結
    • java集合的一種錯誤檢測機制,當多個線程對集合進行結構上的改變的操作時,有可能會產生 fail-fast 機制。
      • 例如:假設存在兩個線程(線程1、線程2),線程1通過Iterator在遍歷集合A中的元素,在某個時候線程2修改了集合A的結構(是結構上面的修改,而不是簡單的修改集合元素的內容),那麽這個時候程序就會拋出 ConcurrentModificationException 異常,從而產生fail-fast機制。
    • 原因:
      • 叠代器在遍歷時直接訪問集合中的內容,並且在遍歷過程中使用一個 modCount 變量。集合在被遍歷期間如果內容發生變化,就會改變modCount的值。每當叠代器使用hashNext()/next()遍歷下一個元素之前,都會檢測modCount變量是否為expectedmodCount值,是的話就返回遍歷;否則拋出異常,終止遍歷。
    • 解決辦法:
      • 1.在遍歷過程中,所有涉及到改變modCount值得地方全部加上synchronized。
      • 2.使用CopyOnWriteArrayList來替換ArrayList

3.0.0.5 ArrayList,Vector和LinkList的區別,底層分別是怎麽實現的?存儲空間是如何擴容的?什麽是加載因子?

  • ArrayList
    • ArrayList的底層結構是數組,可用索引實現快速查找;是動態數組,相比於數組容量可實現動態增長。
    • ArrayList非線程安全,建議在單線程中才使用ArrayList,而在多線程中可以選擇Vector或者CopyOnWriteArrayList;默認初始容量為10,每次擴容為原來的1.5倍
  • Vector
    • 和ArrayList幾乎是一樣的,Vector使用了synchronized關鍵字,是線程安全的,比ArrayList開銷更大,訪問更慢;默認初始容量為10,默認每次擴容為原來的2倍,可通過capacityIncrement屬性設置
  • LinkList
    • LinkedList底層結構是鏈表,增刪速度快;是一個雙向循環鏈表,也可以被當作堆棧、隊列或雙端隊列

3.0.0.6 如何理解ArrayList的擴容消耗?Arrays.asList方法後的List可以擴容嗎?ArrayList如何序列化?

  • 如何理解ArrayList的擴容消耗
    • 由於ArrayList使用elementData = Arrays.copyOf(elementData, newCapacity);進行擴容,而每次都會重新創建一個newLength長度的數組,所以擴容的空間復雜度為O(n),時間復雜度為O(n)
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
    
  • Arrays.asList方法後的List可以擴容嗎?
    • 不能,asList返回的List為只讀的。其原因為:asList方法返回的ArrayList是Arrays的一個內部類,並且沒有實現add,remove等操作
  • List怎麽實現排序?
    • 實現排序,可以使用自定義排序:list.sort(new Comparator(){...})
    • 或者使用Collections進行快速排序:Collections.sort(list)
  • ArrayList如何序列化?
    • ArrayList 基於數組實現,並且具有動態擴容特性,因此保存元素的數組不一定都會被使用,那麽就沒必要全部進行序列化。
    • 技術博客大總結
    • 保存元素的數組 elementData 使用 transient 修飾,該關鍵字聲明數組默認不會被序列化。
    transient Object[] elementData; // non-private to simplify nested class access
    
    • ArrayList 實現了 writeObject() 和 readObject() 來控制只序列化數組中有元素填充那部分內容。
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
        s.defaultReadObject();
        s.readInt(); // ignored
        if (size > 0) {
            ensureCapacityInternal(size);
            Object[] a = elementData;
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }
    
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        int expectedModCount = modCount;
        s.defaultWriteObject();
        s.writeInt(size);
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
    
    • 序列化時需要使用 ObjectOutputStream 的 writeObject() 將對象轉換為字節流並輸出。而 writeObject() 方法在傳入的對象存在 writeObject() 的時候會去反射調用該對象的 writeObject() 來實現序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法,原理類似。
    ArrayList list = new ArrayList();
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
    oos.writeObject(list);
    

3.0.0.7 如何理解list集合讀寫機制和讀寫效率?什麽是CopyOnWriteArrayList,它與ArrayList有何不同?

  • 讀寫機制
    • ArrayList在執行插入元素是超過當前數組預定義的最大值時,數組需要擴容,擴容過程需要調用底層System.arraycopy()方法進行大量的數組復制操作;在刪除元素時並不會減少數組的容量(如果需要縮小數組容量,可以調用trimToSize()方法);在查找元素時要遍歷數組,對於非null的元素采取equals的方式尋找。
    • LinkedList在插入元素時,須創建一個新的Entry對象,並更新相應元素的前後元素的引用;在查找元素時,需遍歷鏈表;在刪除元素時,要遍歷鏈表,找到要刪除的元素,然後從鏈表上將此元素刪除即可。
    • Vector與ArrayList僅在插入元素時容量擴充機制不一致。對於Vector,默認創建一個大小為10的Object數組,並將capacityIncrement設置為0;當插入元素數組大小不夠時,如果capacityIncrement大於0,則將Object數組的大小擴大為現有size+capacityIncrement;如果capacityIncrement<=0,則將Object數組的大小擴大為現有大小的2倍。
  • 讀寫效率
    • ArrayList對元素的增加和刪除都會引起數組的內存分配空間動態發生變化。因此,對其進行插入和刪除速度較慢,但檢索速度很快。
    • LinkedList由於基於鏈表方式存放數據,增加和刪除元素的速度較快,但是檢索速度較慢。
  • 什麽是CopyOnWriteArrayList,它與ArrayList有何不同?
    • CopyOnWriteArrayList是ArrayList的一個線程安全的變體,其中所有可變操作(add、set等等)都是通過對底層數組進行一次新的復制來實現的。相比較於ArrayList它的寫操作要慢一些,因為它需要實例的快照。
    • CopyOnWriteArrayList中寫操作需要大面積復制數組,所以性能肯定很差,但是讀操作因為操作的對象和寫操作不是同一個對象,讀之間也不需要加鎖,讀和寫之間的同步處理只是在寫完後通過一個簡單的"="將引用指向新的數組對象上來,這個幾乎不需要時間,這樣讀操作就很快很安全,適合在多線程裏使用,絕對不會發生ConcurrentModificationException ,因此CopyOnWriteArrayList適合使用在讀操作遠遠大於寫操作的場景裏,比如緩存。
    • 技術博客大總結

3.0.1.0 HashSet和TreeSet的區別?是如何保證唯一值的,底層怎麽做到的?

  • HashSet
    • 不能保證元素的排列順序;使用Hash算法來存儲集合中的元素,有良好的存取和查找性能;通過equal()判斷兩個元素是否相等,並兩個元素的hashCode()返回值也相等
  • TreeSet
    • 是SortedSet接口的實現類,根據元素實際值的大小進行排序;采用紅黑樹的數據結構來存儲集合元素;支持兩種排序方法:自然排序(默認情況)和定制排序。前者通過實現Comparable接口中的compareTo()比較兩個元素之間大小關系,然後按升序排列;後者通過實現Comparator接口中的compare()比較兩個元素之間大小關系,實現定制排列

3.0.1.5 HashMap和Hashtable的區別?HashMap在put、get元素的過程?體現了什麽數據結構?

  • HashMap
    • 基於AbstractMap類,實現了Map、Cloneable(能被克隆)、Serializable(支持序列化)接口; 非線程安全;允許存在一個為null的key和任意個為null的value;采用鏈表散列的數據結構,即數組和鏈表的結合;初始容量為16,填充因子默認為0.75,擴容時是當前容量翻倍,即2capacity
  • Hashtable
    • 基於Map接口和Dictionary類;線程安全,開銷比HashMap大,如果多線程訪問一個Map對象,使用Hashtable更好;不允許使用null作為key和value;底層基於哈希表結構;初始容量為11,填充因子默認為0.75,擴容時是容量翻倍+1,即2capacity+1
    • HashTable裏使用的是synchronized關鍵字,這其實是對對象加鎖,鎖住的都是對象整體,當Hashtable的大小增加到一定的時候,性能會急劇下降,因為叠代時需要被鎖定很長的時間。
  • HashMap在put、get元素的過程
    • 向Hashmap中put元素時,首先判斷key是否為空,為空則直接調用putForNullKey(),不為空則計算key的hash值得到該元素在數組中的下標值;如果數組在該位置處沒有元素,就直接保存;如果有,還要比較是否存在相同的key,存在的話就覆蓋原來key的value,否則將該元素保存在鏈頭,先保存的在鏈尾。
    • 從Hashmap中get元素時,計算key的hash值找到在數組中的對應的下標值,返回該key對應的value即可,如果有沖突就遍歷該位置鏈表尋找key相同的元素並返回對應的value
  • 體現了什麽數據結構
    • HashMap采用鏈表散列的數據結構,即數組和鏈表的結合,在Java8後又結合了紅黑樹,當鏈表元素超過8個將鏈表轉換為紅黑樹
    • 技術博客大總結

3.0.1.6 如何保證HashMap線程安全?底層怎麽實現的?HashMap是有序的嗎?如何實現有序?

  • 使用ConcurrentHashMap可保證線程安全
    • ConcurrentHashMap是線程安全的HashMap,它采取鎖分段技術,將數據分成一段一段的存儲,然後給每一段數據配一把鎖,當一個線程占用鎖訪問其中一個段數據的時候,其他段的數據也能被其他線程訪問。在JDK1.8中對ConcurrentHashmap做了兩個改進:
      • 取消segments字段,直接采用transient volatile HashEntry<K,V>[] table保存數據,將數組元素作為鎖,對每一行數據進行加鎖,可減少並發沖突的概率
      • 數據結構由“數組+單向鏈表”變為“數組+單向鏈表+紅黑樹”,使得查詢的時間復雜度可以降低到O(logN),改進一定的性能。
    • 通俗一點解釋:ConcurrentHashMap引入了分割(Segment),可以理解為把一個大的Map拆分成N個小的HashTable,在put方法中,會根據hash(paramK.hashCode())來決定具體存放進哪個Segment,如果查看Segment的put操作,我們會發現內部使用的同步機制是基於lock操作的,這樣就可以對Map的一部分(Segment)進行上鎖,這樣影響的只是將要放入同一個Segment的元素的put操作,保證同步的時候,鎖住的不是整個Map(HashTable就是這麽做的),相對於HashTable提高了多線程環境下的性能,因此HashTable已經被淘汰了。技術博客大總結
  • 使用LinkedHashMap可實現有序
    • HashMap是無序的,而LinkedHashMap是有序的HashMap,默認為插入順序,還可以是訪問順序,基本原理是其內部通過Entry維護了一個雙向鏈表,負責維護Map的叠代順序

3.0.1.7 HashMap存儲兩個對象的hashcode相同會發生什麽?如果兩個鍵的hashcode相同,你如何獲取值對象?

  • HashMap存儲兩個對象的hashcode相同會發生什麽?
    • 錯誤回答:因為hashcode相同,所以兩個對象是相等的,HashMap將會拋出異常,或者不會存儲它們。
    • 正確回答:兩個對象就算hashcode相同,但是它們可能並不相等。如果不明白,可以先看看我的這篇博客:Hash和HashCode深入理解。回答“因為hashcode相同,所以它們的bucket位置相同,‘碰撞’會發生。因為HashMap使用鏈表存儲對象,這個Entry(包含有鍵值對的Map.Entry對象)會存儲在鏈表中。
  • HashMap1.7和1.8的區別
    • 在JDK1.6,JDK1.7中,HashMap采用數組+鏈表實現,即使用鏈表處理沖突,同一hash值的鏈表都存儲在一個鏈表裏。但是當位於一個鏈表中的元素較多,即hash值相等的元素較多時,通過key值依次查找的效率較低。
    • JDK1.8中,HashMap采用位數組+鏈表+紅黑樹實現,當鏈表長度超過閾值(8)時,將鏈表轉換為紅黑樹,這樣大大減少了查找時間。
  • 如果兩個鍵的hashcode相同,你如何獲取值對象?
    • 當調用get()方法,HashMap會使用鍵對象的hashcode找到bucket位置,然後獲取值對象。當然如果有兩個值對象儲存在同一個bucket,將會遍歷鏈表直到找到值對象。
    • 在沒有值對象去比較,如何確定確定找到值對象的?因為HashMap在鏈表中存儲的是鍵值對,找到bucket位置之後,會調用keys.equals()方法去找到鏈表中正確的節點,最終找到要找的值對象。
    • 技術博客大總結

3.0.1.8 HashMap為什麽不直接使用hashCode()處理後的哈希值直接作為table的下標?

  • 不直接使用hashCode()處理後的哈希值
    • hashCode()方法返回的是int整數類型,其範圍為-(231)~(231-1),約有40億個映射空間,而HashMap的容量範圍是在16(初始化默認值)~2 ^ 30,HashMap通常情況下是取不到最大值的,並且設備上也難以提供這麽多的存儲空間,從而導致通過hashCode()計算出的哈希值可能不在數組大小範圍內,進而無法匹配存儲位置;
  • HashMap是使用了哪些方法來有效解決哈希沖突的
    • 1.使用鏈地址法(使用散列表)來鏈接擁有相同hash值的數據;
    • 2.使用2次擾動函數(hash函數)來降低哈希沖突的概率,使得數據分布更平均;
    • 3.引入紅黑樹進一步降低遍歷的時間復雜度,使得遍歷更快;
  • 如何解決匹配存儲位置問題
    • HashMap自己實現了自己的hash()方法,通過兩次擾動使得它自己的哈希值高低位自行進行異或運算,降低哈希碰撞概率也使得數據分布更平均;
    • 在保證數組長度為2的冪次方的時候,使用hash()運算之後的值與運算(&)(數組長度 - 1)來獲取數組下標的方式進行存儲,這樣一來是比取余操作更加有效率,二來也是因為只有當數組長度為2的冪次方時,h&(length-1)才等價於h%length,三來解決了“哈希值與數組大小範圍不匹配”的問題;
  • 為什麽數組長度要保證為2的冪次方呢?
    • 只有當數組長度為2的冪次方時,h&(length-1)才等價於h%length,即實現了key的定位,2的冪次方也可以減少沖突次數,提高HashMap的查詢效率;
    • 技術博客大總結
    • 如果 length 為 2 的次冪 則 length-1 轉化為二進制必定是 11111……的形式,在於 h 的二進制與操作效率會非常的快,而且空間不浪費;如果 length 不是 2 的次冪,比如 length 為 15,則 length - 1 為 14,對應的二進制為 1110,在於 h 與操作,最後一位都為 0 ,而 0001,0011,0101,1001,1011,0111,1101 這幾個位置永遠都不能存放元素了,空間浪費相當大,更糟的是這種情況中,數組可以使用的位置比數組長度小了很多,這意味著進一步增加了碰撞的幾率,減慢了查詢的效率!這樣就會造成空間的浪費。

3.0.1.9 為什麽HashMap中String、Integer這樣的包裝類適合作為K?為啥不用其他作key值?

  • 為什麽HashMap中String、Integer這樣的包裝類適合作為K?
    • String、Integer等包裝類的特性能夠保證Hash值的不可更改性和計算準確性,能夠有效的減少Hash碰撞的幾率
      • 都是final類型,即不可變性,保證key的不可更改性,不會存在獲取hash值不同的情況
      • 內部已重寫了equals()、hashCode()等方法,遵守了HashMap內部的規範(不清楚可以去上面看看putValue的過程),不容易出現Hash值計算錯誤的情況;
  • 想要讓自己的Object作為K應該怎麽辦呢?
    • 重寫hashCode()和equals()方法
      • 重寫hashCode()是因為需要計算存儲數據的存儲位置,需要註意不要試圖從散列碼計算中排除掉一個對象的關鍵部分來提高性能,這樣雖然能更快但可能會導致更多的Hash碰撞;
      • 重寫equals()方法,需要遵守自反性、對稱性、傳遞性、一致性以及對於任何非null的引用值x,x.equals(null)必須返回false的這幾個特性,目的是為了保證key在哈希表中的唯一性;
  • 總結
    • 采用合適的equals()和hashCode()方法的話,將會減少碰撞的發生,提高效率。不可變性使得能夠緩存不同鍵的hashcode,這將提高整個獲取對象的速度,使用String,Interger這樣的wrapper類作為鍵是非常好的選擇。
    • 技術博客大總結

3.0.2.0 HashMap是如何擴容的?如何理解HashMap的大小超過了負載因子定義的容量?重新調整HashMap大小存在什麽問題嗎?

  • HashMap是為啥要擴容
    • 當鏈表數組的容量超過初始容量*加載因子(默認0.75)時,再散列將鏈表數組擴大2倍,把原鏈表數組的搬移到新的數組中。為什麽需要使用加載因子?為什麽需要擴容呢?因為如果填充比很大,說明利用的空間很多,如果一直不進行擴容的話,鏈表就會越來越長,這樣查找的效率很低,擴容之後,將原來鏈表數組的每一個鏈表分成奇偶兩個子鏈表分別掛在新鏈表數組的散列位置,這樣就減少了每個鏈表的長度,增加查找效率。
  • 如何理解HashMap的大小超過了負載因子(load factor)定義的容量?
    • 默認的負載因子大小為0.75,也就是說,當一個map填滿了75%的bucket時候,和其它集合類(如ArrayList等)一樣,將會創建原來HashMap大小的兩倍的bucket數組,來重新調整map的大小,並將原來的對象放入新的bucket數組中。這個過程叫作rehashing,因為它調用hash方法找到新的bucket位置。
  • 重新調整HashMap大小存在什麽問題嗎?技術博客大總結
    • 當多線程的情況下,可能產生條件競爭。當重新調整HashMap大小的時候,確實存在條件競爭,因為如果兩個線程都發現HashMap需要重新調整大小了,它們會同時試著調整大小。在調整大小的過程中,存儲在鏈表中的元素的次序會反過來,因為移動到新的bucket位置的時候,HashMap並不會將元素放在鏈表的尾部,而是放在頭部,這是為了避免尾部遍歷(tail traversing)。如果條件競爭發生了,那麽就死循環了。

其他介紹

01.關於博客匯總鏈接

  • 1.技術博客匯總
  • 2.開源項目匯總
  • 3.生活博客匯總
  • 4.喜馬拉雅音頻匯總
  • 5.其他匯總

02.關於我的博客

  • 我的個人站點:www.yczbj.org,www.ycbjie.cn
  • github:https://github.com/yangchong211
  • 知乎:https://www.zhihu.com/people/yang-chong-69-24/pins/posts
  • 簡書:http://www.jianshu.com/u/b7b2c6ed9284
  • csdn:http://my.csdn.net/m0_37700275
  • 喜馬拉雅聽書:http://www.ximalaya.com/zhubo/71989305/
  • 開源中國:https://my.oschina.net/zbj1618/blog
  • 泡在網上的日子:http://www.jcodecraeer.com/member/content_list.php?channelid=1
  • 郵箱:[email protected]
  • 阿裏雲博客:https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV
  • segmentfault頭條:https://segmentfault.com/u/xiangjianyu/articles
  • 掘金:https://juejin.im/user/5939433efe88c2006afa0c6e

03.Java數據結構問題