本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章首發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《走進JavaWeb技術世界》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從入門到進階，從servlet到框架，從ssm再到SpringBoot，一步步地學習JavaWeb基礎知識，並上手進行實戰，接著瞭解JavaWeb專案中經常要使用的技術和元件，包括日誌元件、Maven、Junit，等等內容，以便讓你更完整地瞭解整個JavaWeb技術體系，形成自己的知識框架。為了更好地總結和檢驗你的學習成果，本系列文章也會提供每個知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

**文末贈送8000G的Java架構師學習資料，需要的朋友可以到文末了解領取方式，資料包括Java基礎、進階、專案和架構師等免費學習資料，更有資料庫、分散式、微服務等熱門技術學習影片，內容豐富，兼顧原理和實踐，另外也將贈送作者原創的Java學習指南、Java程式設計師面試指南等乾貨資源）**

今天我們來探索一下Java集合類中的一些技術細節。主要是對一些比較容易被遺漏和誤解的知識點做一些講解和補充。可能不全面，還請諒解。

## 初始容量

集合是我們在Java程式設計中使用非常廣泛的，它就像大海，海納百川，像萬能容器，盛裝萬物，而且這個大海，萬能容器還可以無限變大（如果條件允許）。當這個海、容器的量變得非常大的時候，它的初始容量就會顯得很重要了，因為挖海、擴容是需要消耗大量的人力物力財力的。

同樣的道理，Collection的初始容量也顯得異常重要。所以：對於已知的情景，請為集合指定初始容量。

public static void main(String[] args) {
        StudentVO student = null;
        long begin1 = System.currentTimeMillis();
        List<studentvo> list1 = new ArrayList<>();
        for(int i = 0 ; i < 1000000; i++){
            student = new StudentVO(i,"chenssy_"+i,i);
            list1.add(student);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("list1 time：" + (end1 - begin1));
        
        long begin2 = System.currentTimeMillis();
        List<studentvo> list2 = new ArrayList<>(1000000);
        for(int i = 0 ; i < 1000000; i++){
            student = new StudentVO(i,"chenssy_"+i,i);
            list2.add(student);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("list2 time：" + (end2 - begin2));
    }
上面程式碼兩個list都是插入1000000條資料，只不過list1沒有沒有申請初始化容量，而list2初始化容量1000000。那執行結果如下：

list1 time：1638
    list2 time：921

從上面的執行結果我們可以看出list2的速度是list1的兩倍左右。在前面LZ就提過，ArrayList的擴容機制是比較消耗資源的。我們先看ArrayList的add方法：

public boolean add(E e) {  
            ensureCapacity(size + 1);   
            elementData[size++] = e;  
            return true;  
        }  
    
    public void ensureCapacity(int minCapacity) {  
        modCount++;         //修改計數器
        int oldCapacity = elementData.length;    
        //當前需要的長度超過了陣列長度，進行擴容處理
        if (minCapacity > oldCapacity) {  
            Object oldData[] = elementData;  
            //新的容量 = 舊容量 * 1.5 + 1
            int newCapacity = (oldCapacity * 3)/2 + 1;  
                if (newCapacity < minCapacity)  
                    newCapacity = minCapacity;  
          //陣列複製，生成新的陣列 
          elementData = Arrays.copyOf(elementData, newCapacity);  
        }  
    }
ArrayList每次新增一個元素，就會檢測ArrayList的當前容量是否已經到達臨界點，如果到達臨界點則會擴容1.5倍。然而ArrayList的擴容以及陣列的複製生成新的陣列是相當耗資源的。所以若我們事先已知集合的使用場景，知道集合的大概範圍，我們最好是指定初始化容量，這樣對資源的利用會更加好，尤其是大資料量的前提下，效率的提升和資源的利用會顯得更加具有優勢。

## asList的缺陷

在實際開發過程中我們經常使用asList講陣列轉換為List，這個方法使用起來非常方便，但是asList方法存在幾個缺陷：

### 避免使用基本資料型別陣列轉換為列表

使用8個基本型別陣列轉換為列表時會存在一個比較有味的缺陷。先看如下程式：

public static void main(String[] args) {
            int[] ints = {1,2,3,4,5};
            List list = Arrays.asList(ints);
            System.out.println("list'size：" + list.size());
        }
    ------------------------------------
    outPut：
    list'size：1
程式的執行結果並沒有像我們預期的那樣是5而是逆天的1，這是什麼情況？先看原始碼：

public static <t> List<t> asList(T... a) {
            return new ArrayList<>(a);
        }

asList接受的引數是一個泛型的變長引數，我們知道基本資料型別是無法髮型化的，也就是說8個基本型別是無法作為asList的引數的， 要想作為泛型引數就必須使用其所對應的包裝型別。但是這個這個例項中為什麼沒有出錯呢？

因為該例項是將int型別的陣列當做其引數，而在Java中陣列是一個物件，它是可以泛型化的。所以該例子是不會產生錯誤的。既然例子是將整個int型別的陣列當做泛型引數，那麼經過asList轉換就只有一個int 的列表了。如下：

public static void main(String[] args) {
        int[] ints = {1,2,3,4,5};
        List list = Arrays.asList(ints);
        System.out.println("list 的型別:" + list.get(0).getClass());
        System.out.println("list.get(0) == ints：" + list.get(0).equals(ints));
    }
--------------------------------------------
outPut:
list 的型別:class [I
list.get(0) == ints：true
從這個執行結果我們可以充分證明list裡面的元素就是int陣列。弄清楚這點了，那麼修改方法也就一目瞭然了：將int 改變為Integer。

public static void main(String[] args) {
            Integer[] ints = {1,2,3,4,5};
            List list = Arrays.asList(ints);
            System.out.println("list'size：" + list.size());
            System.out.println("list.get(0) 的型別:" + list.get(0).getClass());
            System.out.println("list.get(0) == ints[0]：" + list.get(0).equals(ints[0]));
        }
    ----------------------------------------
    outPut:
    list'size：5
    list.get(0) 的型別:class java.lang.Integer
    list.get(0) == ints[0]：true

### asList產生的列表不可操作

對於上面的例項我們再做一個小小的修改：

public static void main(String[] args) {
            Integer[] ints = {1,2,3,4,5};
            List list = Arrays.asList(ints);
            list.add(6);
        }

該例項就是講ints透過asList轉換為list 類別，然後再透過add方法加一個元素，這個例項簡單的不能再簡單了，但是執行結果呢？打出我們所料：

Exception in thread "main" java.lang.UnsupportedOperationException
        at java.util.AbstractList.add(Unknown Source)
        at java.util.AbstractList.add(Unknown Source)
        at com.chenssy.test.arrayList.AsListTest.main(AsListTest.java:10)

執行結果盡然丟擲UnsupportedOperationException異常，該異常表示list不支援add方法。這就讓我們鬱悶了，list怎麼可能不支援add方法呢？難道jdk腦袋堵塞了？我們再看asList的原始碼：

public static <t> List<t> asList(T... a) {
            return new ArrayList<>(a);
        }
asList接受引數後，直接new 一個ArrayList，到這裡看應該是沒有錯誤的啊？別急，再往下看:

private static class ArrayList<e> extends AbstractList<e>
        implements RandomAccess, java.io.Serializable{
            private static final long serialVersionUID = -2764017481108945198L;
            private final E[] a;
    
            ArrayList(E[] array) {
                if (array==null)
                    throw new NullPointerException();
                a = array;
            }
            //.................
        }
這是ArrayList的原始碼,從這裡我們可以看出,此ArrayList不是java.util.ArrayList，他是Arrays的內部類。

該內部類提供了size、toArray、get、set、indexOf、contains方法，而像add、remove等改變list結果的方法從AbstractList父類繼承過來，同時這些方法也比較奇葩，它直接丟擲UnsupportedOperationException異常：

public boolean add(E e) {
            add(size(), e);
            return true;
        }
        
        public E set(int index, E element) {
            throw new UnsupportedOperationException();
        }
        
        public void add(int index, E element) {
            throw new UnsupportedOperationException();
        }
        
        public E remove(int index) {
            throw new UnsupportedOperationException();
        }

透過這些程式碼可以看出asList返回的列表只不過是一個披著list的外衣，它並沒有list的基本特性（變長）。該list是一個長度不可變的列表，傳入引數的陣列有多長，其返回的列表就只能是多長。所以：：不要試圖改變asList返回的列表，否則你會自食苦果。

## subList的缺陷
我們經常使用subString方法來對String物件進行分割處理，同時我們也可以使用subList、subMap、subSet來對List、Map、Set進行分割處理，但是這個分割存在某些瑕疵。

### subList返回僅僅只是一個檢視

首先我們先看如下例項：

public static void main(String[] args) {
        List<integer> list1 = new ArrayList<integer>();
        list1.add(1);
        list1.add(2);
        
        //透過建構函式新建一個包含list1的列表 list2
        List<integer> list2 = new ArrayList<integer>(list1);
        
        //透過subList生成一個與list1一樣的列表 list3
        List<integer> list3 = list1.subList(0, list1.size());
        
        //修改list3
        list3.add(3);
        
        System.out.println("list1 == list2：" + list1.equals(list2));
        System.out.println("list1 == list3：" + list1.equals(list3));
    }

這個例子非常簡單，無非就是透過建構函式、subList重新生成一個與list1一樣的list，然後修改list3，最後比較list1 == list2?、list1 == list3?。

按照我們常規的思路應該是這樣的：因為list3透過add新增了一個元素，那麼它肯定與list1不等，而list2是透過list1構造出來的，所以應該相等，所以結果應該是：

list1 == list2：true
    list1 == list3: false
首先我們先不論結果的正確與否，我們先看subList的原始碼：

public List<e> subList(int fromIndex, int toIndex) {
            subListRangeCheck(fromIndex, toIndex, size);
            return new SubList(this, 0, fromIndex, toIndex);
    }

subListRangeCheck方式是判斷fromIndex、toIndex是否合法，如果合法就直接返回一個subList物件，注意在產生該new該物件的時候傳遞了一個引數 this ，該引數非常重要，因為他代表著原始list。

/**
     * 繼承AbstractList類，實現RandomAccess介面
     */
    private class SubList extends AbstractList<e> implements RandomAccess {
        private final AbstractList<e> parent;    //列表
        private final int parentOffset;   
        private final int offset;
        int size;

//建構函式
        SubList(AbstractList<e> parent,
                int offset, int fromIndex, int toIndex) {
            this.parent = parent;
            this.parentOffset = fromIndex;
            this.offset = offset + fromIndex;
            this.size = toIndex - fromIndex;
            this.modCount = ArrayList.this.modCount;
        }
    
        //set方法
        public E set(int index, E e) {
            rangeCheck(index);
            checkForComodification();
            E oldValue = ArrayList.this.elementData(offset + index);
            ArrayList.this.elementData[offset + index] = e;
            return oldValue;
        }
    
        //get方法
        public E get(int index) {
            rangeCheck(index);
            checkForComodification();
            return ArrayList.this.elementData(offset + index);
        }
    
        //add方法
        public void add(int index, E e) {
            rangeCheckForAdd(index);
            checkForComodification();
            parent.add(parentOffset + index, e);
            this.modCount = parent.modCount;
            this.size++;
        }
    
        //remove方法
        public E remove(int index) {
            rangeCheck(index);
            checkForComodification();
            E result = parent.remove(parentOffset + index);
            this.modCount = parent.modCount;
            this.size--;
            return result;
        }
    }

該SubLsit是ArrayList的內部類，它與ArrayList一樣，都是繼承AbstractList和實現RandomAccess介面。同時也提供了get、set、add、remove等list常用的方法。但是它的建構函式有點特殊，在該建構函式中有兩個地方需要注意：

1、this.parent = parent;而parent就是在前面傳遞過來的list，也就是說this.parent就是原始list的引用。

2、this.offset = offset + fromIndex;this.parentOffset = fromIndex;。同時在建構函式中它甚至將modCount（fail-fast機制）傳遞過來了。

我們再看get方法，在get方法中return ArrayList.this.elementData(offset + index);

這段程式碼可以清晰表明get所返回就是原列表offset + index位置的元素。同樣的道理還有add方法裡面的：

parent.add(parentOffset + index, e);
this.modCount = parent.modCount;
remove方法裡面的

E result = parent.remove(parentOffset + index);
this.modCount = parent.modCount;

誠然，到了這裡我們可以判斷subList返回的SubList同樣也是AbstractList的子類，同時它的方法如get、set、add、remove等都是在原列表上面做操作，它並沒有像subString一樣生成一個新的物件。

所以subList返回的只是原列表的一個檢視，它所有的操作最終都會作用在原列表上。

那麼從這裡的分析我們可以得出上面的結果應該恰恰與我們上面的答案相反：

list1 == list2：false
list1 == list3：true

### subList生成子列表後，不要試圖去操作原列表

從上面我們知道subList生成的子列表只是原列表的一個檢視而已，如果我們操作子列表它產生的作用都會在原列表上面表現，但是如果我們操作原列表會產生什麼情況呢？

public static void main(String[] args) {
        List<integer> list1 = new ArrayList<integer>();
        list1.add(1);
        list1.add(2);
        
        //透過subList生成一個與list1一樣的列表 list3
        List<integer> list3 = list1.subList(0, list1.size());
        //修改list1
        list1.add(3);
        
        System.out.println("list1'size：" + list1.size());
        System.out.println("list3'size：" + list3.size());
    }
該例項如果不產生意外，那麼他們兩個list的大小都應該都是3，但是偏偏事與願違，事實上我們得到的結果是這樣的：

list1'size：3
    Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.ArrayList$SubList.checkForComodification(Unknown Source)
        at java.util.ArrayList$SubList.size(Unknown Source)
        at com.chenssy.test.arrayList.SubListTest.main(SubListTest.java:17)
list1正常輸出，但是list3就丟擲ConcurrentModificationException異常，看過我另一篇部落格的同仁肯定對這個異常非常，fail-fast？不錯就是fail-fast機制，在fail-fast機制中，LZ花了很多力氣來講述這個異常，所以這裡LZ就不對這個異常多講了。我們再看size方法：

public int size() {
                checkForComodification();
                return this.size;
            }
size方法首先會透過checkForComodification驗證，然後再返回this.size。

private void checkForComodification() {
                if (ArrayList.this.modCount != this.modCount)
                    throw new ConcurrentModificationException();
            }
該方法表明當原列表的modCount與this.modCount不相等時就會丟擲ConcurrentModificationException。

同時我們知道modCount 在new的過程中 "繼承"了原列表modCount，只有在修改該列表（子列表）時才會修改該值（先表現在原列表後作用於子列表）。

而在該例項中我們是操作原列表，原列表的modCount當然不會反應在子列表的modCount上啦，所以才會丟擲該異常。

對於子列表檢視，它是動態生成的，生成之後就不要操作原列表了，否則必然都導致檢視的不穩定而丟擲異常。最好的辦法就是將原列表設定為只讀狀態，要操作就操作子列表：

//透過subList生成一個與list1一樣的列表 list3

List<integer> list3 = list1.subList(0, list1.size());

//對list1設定為只讀狀態

list1 = Collections.unmodifiableList(list1);

### 推薦使用subList處理區域性列表

在開發過程中我們一定會遇到這樣一個問題：獲取一堆資料後，需要刪除某段資料。例如，有一個列表存在1000條記錄，我們需要刪除100-200位置處的資料，可能我們會這樣處理：

for(int i = 0 ; i < list1.size() ; i++){
       if(i >= 100 && i <= 200){
           list1.remove(i);
           /*
            * 當然這段程式碼存在問題，list remove之後後面的元素會填充上來，
             * 所以需要對i進行簡單的處理，當然這個不是這裡討論的問題。
             */
       }
    }
這個應該是我們大部分人的處理方式吧，其實還有更好的方法，利用subList。在前面LZ已經講過，子列表的操作都會反映在原列表上。所以下面一行程式碼全部搞定：

list1.subList(100, 200).clear();
簡單而不失華麗！！！！！

## 保持compareTo和equals同步
在Java中我們常使用Comparable介面來實現排序，其中compareTo是實現該介面方法。我們知道compareTo返回0表示兩個物件相等，返回正數表示大於，返回負數表示小於。同時我們也知道equals也可以判斷兩個物件是否相等，那麼他們兩者之間是否存在關聯關係呢？

public class Student implements Comparable<student>{
        private String id;
        private String name;
        private int age;
        
        public Student(String id,String name,int age){
            this.id = id;
            this.name = name;
            this.age = age;
        }
    
        public boolean equals(Object obj){
            if(obj == null){
                return false;
            }
            
            if(this == obj){
                return true;
            }
            
            if(obj.getClass() != this.getClass()){
                return false;
            }
            
            Student student = (Student)obj;
            if(!student.getName().equals(getName())){
                return false;
            }
            
            return true;
        }
        
        public int compareTo(Student student) {
            return this.age - student.age;
        }
    
        /** 省略getter、setter方法 */
    }
Student類實現Comparable介面和實現equals方法，其中compareTo是根據age來比對的，equals是根據name來比對的。

public static void main(String[] args){
            List<student> list = new ArrayList<>();
            list.add(new Student("1", "chenssy1", 24));
            list.add(new Student("2", "chenssy1", 26));
            
            Collections.sort(list);   //排序
            
            Student student = new Student("2", "chenssy1", 26);
            
            //檢索student在list中的位置
            int index1 = list.indexOf(student);
            int index2 = Collections.binarySearch(list, student);
            
            System.out.println("index1 = " + index1);
            System.out.println("index2 = " + index2);
        }

按照常規思路來說應該兩者index是一致的，因為他們檢索的是同一個物件，但是非常遺憾，其執行結果：

index1 = 0
index2 = 1

> 為什麼會產生這樣不同的結果呢？這是因為indexOf和binarySearch的實現機制不同。
>
> indexOf是基於equals來實現的只要equals返回TRUE就認為已經找到了相同的元素。
>
> 而binarySearch是基於compareTo方法的，當compareTo返回0 時就認為已經找到了該元素。
>
> 在我們實現的Student類中我們覆寫了compareTo和equals方法，但是我們的compareTo、equals的比較依據不同，一個是基於age、一個是基於name。

比較依據不同那麼得到的結果很有可能會不同。所以知道了原因，我們就好修改了：將兩者之間的比較依據保持一致即可。

對於compareTo和equals兩個方法我們可以總結為：compareTo是判斷元素在排序中的位置是否相等，equals是判斷元素是否相等，既然一個決定排序位置，一個決定相等，所以我們非常有必要確保當排序位置相同時，其equals也應該相等。

使其相等的方式就是兩者應該依附於相同的條件。當compareto相等時equals也應該相等，而compareto不相等時equals不應該相等，並且compareto依據某些屬性來決定排序。

## 參考文章
https://www.cnblogs.com/galibujianbusana/p/6600226.html

http://blog.itpub.net/69906029/viewspace-2641300/

https://www.cnblogs.com/itxiaok/p/10356553.html</student></student></integer></integer></integer></integer></e></e></e></e></integer></integer></integer></integer></integer></e></e></t></t></t></t></studentvo></studentvo>

Java集合詳解8：Java集合類細節精講，細節決定成敗

相關文章