《Java集合詳解系列》是我在完成夯實Java基礎篇的系列部落格後準備開始寫的新系列。

這些文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視

> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star、fork哈

文章首發於我的個人部落格：

> www.how2playlife.com

今天我們來探索一下LIterator，fail-fast機制與比較器的原始碼。

本文參考 cmsblogs.com/p=1185

## Iterator

迭代對於我們搞Java的來說絕對不陌生。我們常常使用JDK提供的迭代介面進行Java集合的迭代。

Iterator iterator = list.iterator();
            while(iterator.hasNext()){
                String string = iterator.next();
                do something
            }
迭代其實我們可以簡單地理解為遍歷，是一個標準化遍歷各類容器裡面的所有物件的方法類，它是一個很典型的設計模式。Iterator模式是用於遍歷集合類的標準訪問方法。

它可以把訪問邏輯從不同型別的集合類中抽象出來，從而避免向客戶端暴露集合的內部結構。 在沒有迭代器時我們都是這麼進行處理的。如下：

對於陣列我們是使用下標來進行處理的

int[] arrays = new int[10];
       for(int i = 0 ; i  arrays.length ; i++){
           int a = arrays[i];
           do something
       }

對於ArrayList是這麼處理的

ListString list = new ArrayListString();
       for(int i = 0 ; i  list.size() ;  i++){
          String string = list.get(i);
          do something
       }

對於這兩種方式，我們總是都事先知道集合的內部結構，訪問程式碼和集合本身是緊密耦合的，無法將訪問邏輯從集合類和客戶端程式碼中分離出來。同時每一種集合對應一種遍歷方法，客戶端程式碼無法複用。

在實際應用中如何需要將上面將兩個集合進行整合是相當麻煩的。所以為了解決以上問題，Iterator模式騰空出世，它總是用同一種邏輯來遍歷集合。

使得客戶端自身不需要來維護集合的內部結構，所有的內部狀態都由Iterator來維護。客戶端從不直接和集合類打交道，它總是控制Iterator，向它傳送向前，向後，取當前元素的命令，就可以間接遍歷整個集合。

上面只是對Iterator模式進行簡單的說明，下面我們看看Java中Iterator介面，看他是如何來進行實現的。

### java.util.Iterator

在Java中Iterator為一個介面，它只提供了迭代了基本規則，在JDK中他是這樣定義的：對 collection 進行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器與列舉有兩點不同：

1、迭代器允許呼叫者利用定義良好的語義在迭代期間從迭代器所指向的 collection 移除元素。
    
    2、方法名稱得到了改進。

其介面定義如下：

public interface Iterator {
    　　boolean hasNext();
    　　Object next();
    　　void remove();
    }
其中：

Object next()：返回迭代器剛越過的元素的引用，返回值是Object，需要強制轉換成自己需要的型別
    
    boolean hasNext()：判斷容器內是否還有可供訪問的元素
    
    void remove()：刪除迭代器剛越過的元素

對於我們而言，我們只一般只需使用next()、hasNext()兩個方法即可完成迭代。如下：

for(Iterator it = c.iterator(); it.hasNext(); ) {
    　　Object o = it.next();
    　　 do something
    }

==前面闡述了Iterator有一個很大的優點,就是我們不必知道集合的內部結果,集合的內部結構、狀態由Iterator來維持，透過統一的方法hasNext()、next()來判斷、獲取下一個元素，至於具體的內部實現我們就不用關心了。==

但是作為一個合格的程式設計師我們非常有必要來弄清楚Iterator的實現。下面就ArrayList的原始碼進行分析分析。

### 各個集合的Iterator的實現

下面就ArrayList的Iterator實現來分析，其實如果我們理解了ArrayList、Hashset、TreeSet的資料結構，內部實現，對於他們是如何實現Iterator也會胸有成竹的。因為ArrayList的內部實現採用陣列，所以我們只需要記錄相應位置的索引即可，其方法的實現比較簡單。

ArrayList的Iterator實現

在ArrayList內部首先是定義一個內部類Itr，該內部類實現Iterator介面，如下：

private class Itr implements IteratorE {
        do something
    }
    而ArrayList的iterator()方法實現：
    
    public IteratorE iterator() {
            return new Itr();
        }

所以透過使用ArrayList.iterator()方法返回的是Itr()內部類，所以現在我們需要關心的就是Itr()內部類的實現：

在Itr內部定義了三個int型的變數：cursor、lastRet、expectedModCount。其中cursor表示下一個元素的索引位置，lastRet表示上一個元素的索引位置

int cursor;             
            int lastRet = -1;     
            int expectedModCount = modCount;

從cursor、lastRet定義可以看出，lastRet一直比cursor少一所以hasNext()實現方法異常簡單，只需要判斷cursor和lastRet是否相等即可。

public boolean hasNext() {
        return cursor != size;
    }

對於next()實現其實也是比較簡單的，只要返回cursor索引位置處的元素即可，然後修改cursor、lastRet即可。

public E next() {
        checkForComodification();
        int i = cursor;    記錄索引位置
        if (i = size)    如果獲取元素大於集合元素個數，則丟擲異常
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i = elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;      cursor + 1
        return (E) elementData[lastRet = i];  lastRet + 1 且返回cursor處元素
    }

checkForComodification()主要用來判斷集合的修改次數是否合法，即用來判斷遍歷過程中集合是否被修改過。

。modCount用於記錄ArrayList集合的修改次數，初始化為0，，每當集合被修改一次（結構上面的修改，內部update不算），如add、remove等方法，modCount + 1，所以如果modCount不變，則表示集合內容沒有被修改。

該機制主要是用於實現ArrayList集合的快速失敗機制，在Java的集合中，較大一部分集合是存在快速失敗機制的，這裡就不多說，後面會講到。

所以要保證在遍歷過程中不出錯誤，我們就應該保證在遍歷過程中不會對集合產生結構上的修改（當然remove方法除外），出現了異常錯誤，我們就應該認真檢查程式是否出錯而不是catch後不做處理。

final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
    對於remove()方法的是實現，它是呼叫ArrayList本身的remove()方法刪除lastRet位置元素，然後修改modCount即可。
    
    public void remove() {
        if (lastRet  0)
            throw new IllegalStateException();
        checkForComodification();
    
        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

這裡就對ArrayList的Iterator實現講解到這裡，對於Hashset、TreeSet等集合的Iterator實現，各位如果感興趣可以繼續研究，個人認為在研究這些集合的原始碼之前，有必要對該集合的資料結構有清晰的認識，這樣會達到事半功倍的效果！！！！

### fail-fast機制
這部分參考http://cmsblogs.com/p=1220

在JDK的Collection中我們時常會看到類似於這樣的話：

例如，ArrayList
    
 注意，迭代器的快速失敗行為無法得到保證，因為一般來說，不可能對是否出現不同步併發修改做出任何硬性保證。快速失敗迭代器會盡最大努力丟擲ConcurrentModificationException。
 因此，為提高這類迭代器的正確性而編寫一個依賴於此異常的程式是錯誤的做法：迭代器的快速失敗行為應該僅用於檢測 bug。

HashMap中：

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在非同步的併發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力丟擲 ConcurrentModificationException。因此，編寫依賴於此異常的程式的做法是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程式錯誤。

在這兩段話中反覆地提到”快速失敗”。那麼何為”快速失敗”機制呢？

“快速失敗”也就是fail-fast，它是Java集合的一種錯誤檢測機制。當多個執行緒對集合進行結構上的改變的操作時，有可能會產生fail-fast機制。

記住是有可能，而不是一定。例如：假設存在兩個執行緒（執行緒1、執行緒2），執行緒1透過Iterator在遍歷集合A中的元素，在某個時候執行緒2修改了集合A的結構（是結構上面的修改，而不是簡單的修改集合元素的內容），那麼這個時候程式就會丟擲 ConcurrentModificationException異常，從而產生fail-fast機制。

#### fail-fast示例

public class FailFastTest {
        private static ListInteger list = new ArrayList();

@desc執行緒one迭代list
          @Projecttest
          @fileFailFastTest.java
          @Authrochenssy
          @data2014年7月26日
         
        private static class threadOne extends Thread{
            public void run() {
                IteratorInteger iterator = list.iterator();
                while(iterator.hasNext()){
                    int i = iterator.next();
                    System.out.println(ThreadOne 遍歷 + i);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

@desc當i == 3時，修改list
          @Projecttest
          @fileFailFastTest.java
          @Authrochenssy
          @data2014年7月26日
         
        private static class threadTwo extends Thread{
            public void run(){
                int i = 0 ; 
                while(i  6){
                    System.out.println(ThreadTwo run： + i);
                    if(i == 3){
                        list.remove(i);
                    }
                    i++;
                }
            }
        }
        
        public static void main(String[] args) {
            for(int i = 0 ; i  10;i++){
                list.add(i);
            }
            new threadOne().start();
            new threadTwo().start();
        }
    }
執行結果：

ThreadOne 遍歷0
    ThreadTwo run：0
    ThreadTwo run：1
    ThreadTwo run：2
    ThreadTwo run：3
    ThreadTwo run：4
    ThreadTwo run：5
    Exception in thread Thread-0 java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
        at java.util.ArrayList$Itr.next(Unknown Source)
        at test.ArrayListTest$threadOne.run(ArrayListTest.java23)

#### fail-fast產生原因

透過上面的示例和講解，我初步知道fail-fast產生的原因就在於程式在對 collection 進行迭代時，某個執行緒對該 collection 在結構上對其做了修改，這時迭代器就會丟擲 ConcurrentModificationException 異常資訊，從而產生 fail-fast。

要了解fail-fast機制，我們首先要對ConcurrentModificationException 異常有所瞭解。當方法檢測到物件的併發修改，但不允許這種修改時就丟擲該異常。同時需要注意的是，該異常不會始終指出物件已經由不同執行緒併發修改，如果單執行緒違反了規則，同樣也有可能會丟擲改異常。

誠然，迭代器的快速失敗行為無法得到保證，它不能保證一定會出現該錯誤，但是快速失敗操作會盡最大努力丟擲ConcurrentModificationException異常，所以因此，為提高此類操作的正確性而編寫一個依賴於此異常的程式是錯誤的做法，正確做法是：ConcurrentModificationException 應該僅用於檢測 bug。下面我將以ArrayList為例進一步分析fail-fast產生的原因。

從前面我們知道fail-fast是在操作迭代器時產生的。現在我們來看看ArrayList中迭代器的原始碼：

private class Itr implements IteratorE {
            int cursor;
            int lastRet = -1;
            int expectedModCount = ArrayList.this.modCount;
    
            public boolean hasNext() {
                return (this.cursor != ArrayList.this.size);
            }
    
            public E next() {
                checkForComodification();
                 省略此處程式碼 
            }
    
            public void remove() {
                if (this.lastRet  0)
                    throw new IllegalStateException();
                checkForComodification();
                 省略此處程式碼 
            }
    
            final void checkForComodification() {
                if (ArrayList.this.modCount == this.expectedModCount)
                    return;
                throw new ConcurrentModificationException();
            }
        }

從上面的原始碼我們可以看出，迭代器在呼叫next()、remove()方法時都是呼叫checkForComodification()方法，該方法主要就是檢測modCount == expectedModCount  若不等則丟擲ConcurrentModificationException 異常，從而產生fail-fast機制。所以要弄清楚為什麼會產生fail-fast機制我們就必須要用弄明白為什麼modCount != expectedModCount ，他們的值在什麼時候發生改變的。

expectedModCount 是在Itr中定義的：int expectedModCount = ArrayList.this.modCount;所以他的值是不可能會修改的，所以會變的就是modCount。modCount是在 AbstractList 中定義的，為全域性變數：

protected transient int modCount = 0;
那麼他什麼時候因為什麼原因而發生改變呢？請看ArrayList的原始碼：

public boolean add(E paramE) {
        ensureCapacityInternal(this.size + 1);
         省略此處程式碼 
    }
    
    private void ensureCapacityInternal(int paramInt) {
        if (this.elementData == EMPTY_ELEMENTDATA)
            paramInt = Math.max(10, paramInt);
        ensureExplicitCapacity(paramInt);
    }
    
    private void ensureExplicitCapacity(int paramInt) {
        this.modCount += 1;    修改modCount
         省略此處程式碼 
    }

public boolean remove(Object paramObject) {
        int i;
        if (paramObject == null)
            for (i = 0; i  this.size; ++i) {
                if (this.elementData[i] != null)
                    continue;
                fastRemove(i);
                return true;
            }
        else
            for (i = 0; i  this.size; ++i) {
                if (!(paramObject.equals(this.elementData[i])))
                    continue;
                fastRemove(i);
                return true;
            }
        return false;
    }

private void fastRemove(int paramInt) {
        this.modCount += 1;   修改modCount
         省略此處程式碼 
    }
    
    public void clear() {
        this.modCount += 1;    修改modCount
         省略此處程式碼 
    }
 從上面的原始碼我們可以看出，ArrayList中無論add、remove、clear方法只要是涉及了改變ArrayList元素的個數的方法都會導致modCount的改變。

所以我們這裡可以初步判斷由於expectedModCount 得值與modCount的改變不同步，導致兩者之間不等從而產生fail-fast機制。知道產生fail-fast產生的根本原因了，我們可以有如下場景：

有兩個執行緒（執行緒A，執行緒B），其中執行緒A負責遍歷list、執行緒B修改list。執行緒A在遍歷list過程的某個時候（此時expectedModCount = modCount=N），執行緒啟動，同時執行緒B增加一個元素，這是modCount的值發生改變（modCount + 1 = N + 1）。

執行緒A繼續遍歷執行next方法時，通告checkForComodification方法發現expectedModCount  = N  ，而modCount = N + 1，兩者不等，這時就丟擲ConcurrentModificationException 異常，從而產生fail-fast機制。

所以，直到這裡我們已經完全瞭解了fail-fast產生的根本原因了。知道了原因就好找解決辦法了。

#### fail-fast解決辦法

透過前面的例項、原始碼分析，我想各位已經基本瞭解了fail-fast的機制，下面我就產生的原因提出解決方案。這裡有兩種解決方案：

方案一：在遍歷過程中所有涉及到改變modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList，這樣就可以解決。但是不推薦，因為增刪造成的同步鎖可能會阻塞遍歷操作。

方案二：使用CopyOnWriteArrayList來替換ArrayList。推薦使用該方案。

CopyOnWriteArrayList為何物？ArrayList 的一個執行緒安全的變體，其中所有可變操作（add、set 等等）都是透過對底層陣列進行一次新的複製來實現的。 該類產生的開銷比較大，但是在兩種情況下，它非常適合使用。

1：在不能或不想進行同步遍歷，但又需要從併發執行緒中排除衝突時。

2：當遍歷操作的數量大大超過可變操作的數量時。遇到這兩種情況使用CopyOnWriteArrayList來替代ArrayList再適合不過了。那麼為什麼CopyOnWriterArrayList可以替代ArrayList呢？

第一、CopyOnWriterArrayList的無論是從資料結構、定義都和ArrayList一樣。它和ArrayList一樣，同樣是實現List介面，底層使用陣列實現。在方法上也包含add、remove、clear、iterator等方法。

第二、CopyOnWriterArrayList根本就不會產生ConcurrentModificationException異常，也就是它使用迭代器完全不會產生fail-fast機制。請看：

private static class COWIteratorE implements ListIteratorE {
             省略此處程式碼 
            public E next() {
                if (!(hasNext()))
                    throw new NoSuchElementException();
                return this.snapshot[(this.cursor++)];
            }
    
             省略此處程式碼 
        }
CopyOnWriterArrayList的方法根本就沒有像ArrayList中使用checkForComodification方法來判斷expectedModCount 與 modCount 是否相等。它為什麼會這麼做，憑什麼可以這麼做呢？我們以add方法為例：

public boolean add(E paramE) {
            ReentrantLock localReentrantLock = this.lock;
            localReentrantLock.lock();
            try {
                Object[] arrayOfObject1 = getArray();
                int i = arrayOfObject1.length;
                Object[] arrayOfObject2 = Arrays.copyOf(arrayOfObject1, i + 1);
                arrayOfObject2[i] = paramE;
                setArray(arrayOfObject2);
                int j = 1;
                return j;
            } finally {
                localReentrantLock.unlock();
            }
        }

final void setArray(Object[] paramArrayOfObject) {
            this.array = paramArrayOfObject;
        }

CopyOnWriterArrayList的add方法與ArrayList的add方法有一個最大的不同點就在於，下面三句程式碼：

Object[] arrayOfObject2 = Arrays.copyOf(arrayOfObject1, i + 1);
    arrayOfObject2[i] = paramE;
    setArray(arrayOfObject2);
就是這三句程式碼使得CopyOnWriterArrayList不會拋ConcurrentModificationException異常。他們所展現的魅力就在於copy原來的array，再在copy陣列上進行add操作，這樣做就完全不會影響COWIterator中的array了。

所以CopyOnWriterArrayList所代表的核心概念就是：任何對array在結構上有所改變的操作（add、remove、clear等），CopyOnWriterArrayList都會copy現有的資料，再在copy的資料上修改，這樣就不會影響COWIterator中的資料了，修改完成之後改變原有資料的引用即可。同時這樣造成的代價就是產生大量的物件，同時陣列的copy也是相當有損耗的。

# Comparable 和 Comparator

Java 中為我們提供了兩種比較機制：Comparable 和 Comparator，他們之間有什麼區別呢？今天來了解一下。

## Comparable

Comparable 在 java.lang包下，是一個介面，內部只有一個方法 compareTo()：

public interface ComparableT {
        public int compareTo(T o);
    }

Comparable 可以讓實現它的類的物件進行比較，具體的比較規則是按照 compareTo 方法中的規則進行。這種順序稱為 自然順序。

compareTo 方法的返回值有三種情況：

e1.compareTo(e2)  0 即 e1  e2
    e1.compareTo(e2) = 0 即 e1 = e2
    e1.compareTo(e2)  0 即 e1  e2

注意：

1.由於 null 不是一個類，也不是一個物件，因此在重寫 compareTo 方法時應該注意 e.compareTo(null) 的情況，即使 e.equals(null) 返回 false，compareTo 方法也應該主動丟擲一個空指標異常 NullPointerException。

2.Comparable 實現類重寫 compareTo 方法時一般要求 e1.compareTo(e2) == 0 的結果要和 e1.equals(e2) 一致。這樣將來使用 SortedSet 等根據類的自然排序進行排序的集合容器時可以保證儲存的資料的順序和想象中一致。
 有人可能好奇上面的第二點如果違反了會怎樣呢？

舉個例子，如果你往一個 SortedSet 中先後新增兩個物件 a 和 b，a b 滿足 (!a.equals(b) && a.compareTo(b) == 0)，同時也沒有另外指定個 Comparator，那當你新增完 a 再新增 b 時會新增失敗返回 false, SortedSet 的 size 也不會增加，因為在 SortedSet 看來它們是相同的，而 SortedSet 中是不允許重複的。

實際上所有實現了 Comparable 介面的 Java 核心類的結果都和 equlas 方法保持一致。 
 實現了 Comparable 介面的 List 或則陣列可以使用 Collections.sort() 或者 Arrays.sort() 方法進行排序。

實現了 Comparable 介面的物件才能夠直接被用作 SortedMap (SortedSet) 的 key，要不然得在外邊指定 Comparator 排序規則。

因此自己定義的類如果想要使用有序的集合類，需要實現 Comparable 介面，比如：

description 測試用的實體類 書, 實現了 Comparable 介面，自然排序
  
      author shixinzhang
      br
      data 1052016
    
    public class BookBean implements Serializable, Comparable {
        private String name;
        private int count;

public BookBean(String name, int count) {
        this.name = name;
        this.count = count;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getCount() {
        return count;
    }
    
    public void setCount(int count) {
        this.count = count;
    }

重寫 equals
      @param o
      @return
     
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BookBean)) return false;
    
        BookBean bean = (BookBean) o;
    
        if (getCount() != bean.getCount()) return false;
        return getName().equals(bean.getName());
    
    }

重寫 hashCode 的計算方法
      根據所有屬性進行 迭代計算，避免重複
      計算 hashCode 時 計算因子 31 見得很多，是一個質數，不能再被除
      @return
     
    @Override
    public int hashCode() {
        呼叫 String 的 hashCode(), 唯一表示一個字串內容
        int result = getName().hashCode();
        乘以 31, 再加上 count
        result = 31  result + getCount();
        return result;
    }
    
    @Override
    public String toString() {
        return BookBean{ +
                name=' + name + ''' +
                , count= + count +
                '}';
    }

當向 TreeSet 中新增 BookBean 時，會呼叫這個方法進行排序
      @param another
      @return
     
    @Override
    public int compareTo(Object another) {
        if (another instanceof BookBean){
            BookBean anotherBook = (BookBean) another;
            int result;
    
            比如這裡按照書價排序
            result = getCount() - anotherBook.getCount();     
    
          或者按照 String 的比較順序
          result = getName().compareTo(anotherBook.getName());
    
            if (result == 0){   當書價一致時，再對比書名。 保證所有屬性比較一遍
                result = getName().compareTo(anotherBook.getName());
            }
            return result;
        }
         一樣就返回 0
        return 0;
    }

上述程式碼還重寫了 equlas(), hashCode() 方法，自定義的類將來可能會進行比較時，建議重寫這些方法。

這裡我想表達的是在有些場景下 equals 和 compareTo 結果要保持一致，這時候不重寫 equals，使用 Object.equals 方法得到的結果會有問題，比如說 HashMap.put() 方法，會先呼叫 key 的 equals 方法進行比較，然後才呼叫 compareTo。

後面重寫 compareTo 時，要判斷某個相同時對比下一個屬性，把所有屬性都比較一次。
 
### Comparator
首先認識一下Comparator：

Comparator 是javase中的介面，位於java.util包下，該介面抽象度極高，有必要掌握該介面的使用
大多數文章告訴大家Comparator是用來排序，但我想說排序是Comparator能實現的功能之一，他不僅限於排序

排序例子：
題目描述
輸入一個正整數陣列，把陣列裡所有數字拼接起來排成一個數，列印能拼接出的所有數字中最小的一個。例如輸入陣列{3，32，321}，則列印出這三個數字能排成的最小數字為321323。

程式碼實現：
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
     
    public class Solution {
        public String PrintMinNumber(int [] s) {
            if(s==null) return null;
            String s1="";
            ArrayList<integer> list=new ArrayList<integer>();
            for(int i=0;i<s.length list.add="" collections.sort="" comparator="">(){
                public int compare(Integer str1,Integer str2){
                    String s1=str1+""+str2;
                    String s2=str2+""+str1;
                    return s1.compareTo(s2);
                }
            });
             for(int j:list){
                    s1+=j;
                 }
            return s1;
        }
    }

一般需要做比較的邏輯都可以使用的上Comparator，最常用的場景就是排序和分組，排序常使用Arrays和Collections的sort方法，而分組則可以使用提供的divider方法。

排序和分組的區別在於: 
排序時，兩個物件比較的結果有三種：大於，等於，小於。 
分組時，兩個物件比較的結果只有兩種：等於(兩個物件屬於同一組)，不等於(兩個物件屬於不同組)

### Java8中使用lambda實現比較器

今天先看看Lambda 表示式的簡單使用：
首先：Lambda表示式的基本語法：(parameters) -> expression或（請注意語句的花括號）
(parameters) -> { statements; }

第一感覺就是這個箭頭感覺有點怪，不過多用幾次習慣就好，它主要是為了把引數列表與Lambda主體分隔開，箭頭左邊的是引數列表，右邊的是Lambda主體。注意：Lambda表示式可以包含多行語句。
在用Lambda 之前，我們先看看之前寫比較器的寫法

Comparator<developer> byName = new Comparator<developer>() {
        @Override
        public int compare(Developer o1, Developer o2) {
            return o1.getName().compareTo(o2.getName());
        }
    };

感覺也不是很複雜，沒幾行程式碼，再來看看Lambda 表示式的寫法：

Comparator<developer> byName =
        (Developer o1, Developer o2)->o1.getName().compareTo(o2.getName());

比之前要簡單許多有木有。
下面再來看看排序功能示例：
先用Collections.sort如下：

public class TestSorting {
        public static void main(String[] args) {
            List<developer> listDevs = getDevelopers();
            System.out.println("Before Sort");
            for (Developer developer : listDevs) {
                System.out.println(developer);
            }
            //安裝年齡排序
            Collections.sort(listDevs, new Comparator<developer>() {
                @Override
                public int compare(Developer o1, Developer o2) {
                    return o1.getAge() - o2.getAge();
                }
            });
            System.out.println("After Sort");
            for (Developer developer : listDevs) {
                System.out.println(developer);
            }
        }
        private static List<developer> getDevelopers() {
            List<developer> result = new ArrayList<developer>();
            result.add(new Developer("mkyong", new BigDecimal("70000"), 33));
            result.add(new Developer("alvin", new BigDecimal("80000"), 20));
            result.add(new Developer("jason", new BigDecimal("100000"), 10));
            result.add(new Developer("iris", new BigDecimal("170000"), 55));
            return result;
        }
    }

輸出結果：
    
    Before Sort
    Developer [name=mkyong, salary=70000, age=33]
    Developer [name=alvin, salary=80000, age=20]
    Developer [name=jason, salary=100000, age=10]
    Developer [name=iris, salary=170000, age=55]
     
    After Sort
    Developer [name=jason, salary=100000, age=10]
    Developer [name=alvin, salary=80000, age=20]
    Developer [name=mkyong, salary=70000, age=33]
    Developer [name=iris, salary=170000, age=55]

看起來整個流程完全沒毛病，下面再來看看Lambda的方式:

public class TestSorting {
        public static void main(String[] args) {
            List<developer> listDevs = getDevelopers();
            System.out.println("Before Sort");
            for (Developer developer : listDevs) {
                System.out.println(developer);
            }
            System.out.println("After Sort");
            //對比上面的程式碼
            listDevs.sort((Developer o1, Developer o2)->o1.getAge()-o2.getAge());
            //這樣列印感覺也不錯
            listDevs.forEach((developer)->System.out.println(developer));
        }
        private static List<developer> getDevelopers() {
            List<developer> result = new ArrayList<developer>();
            result.add(new Developer("mkyong", new BigDecimal("70000"), 33));
            result.add(new Developer("alvin", new BigDecimal("80000"), 20));
            result.add(new Developer("jason", new BigDecimal("100000"), 10));
            result.add(new Developer("iris", new BigDecimal("170000"), 55));
            return result;
        }
    }

輸出結果：

Before Sort
    Developer [name=mkyong, salary=70000, age=33]
    Developer [name=alvin, salary=80000, age=20]
    Developer [name=jason, salary=100000, age=10]
    Developer [name=iris, salary=170000, age=55]
    
    After Sort
    Developer [name=jason, salary=100000, age=10]
    Developer [name=alvin, salary=80000, age=20]
    Developer [name=mkyong, salary=70000, age=33]
    Developer [name=iris, salary=170000, age=55]

總體來說，寫法與之前有較大的改變，寫的程式碼更少，更簡便，感覺還不錯。
後續會帶來更多有關Java8相關的東西，畢竟作為一隻程式狗，得不停的學習才能不被淘汰。Java語言都在不停的改進更新，我們有啥理由不跟上節奏呢？
由於時間問題這裡只是一個簡單的應用，想了解更多可到官網查詢相關示例。

## 總結

Java 中的兩種排序方式：

Comparable 自然排序。（實體類實現）
    Comparator 是定製排序。（無法修改實體類時，直接在呼叫方建立）
    同時存在時採用 Comparator（定製排序）的規則進行比較。

對於一些普通的資料型別（比如 String, Integer, Double…），它們預設實現了Comparable 介面，實現了 compareTo 方法，我們可以直接使用。

而對於一些自定義類，它們可能在不同情況下需要實現不同的比較策略，我們可以新建立 Comparator 介面，然後使用特定的 Comparator 實現進行比較。

這就是 Comparable 和 Comparator 的區別。

## 參考文章

https://blog.csdn.net/weixin_30363263/article/details/80867590

https://www.cnblogs.com/shizhijie/p/7657049.html

https://www.cnblogs.com/xiaweicn/p/8688216.html

https://cmsblogs.com/p=1185

https://blog.csdn.net/android_hl/article/details/53228348

## 微信公眾號

### Java技術江湖

如果大家想要實時關注我更新的文章以及分享的乾貨的話，可以關注我的公眾號【Java技術江湖】一位阿里 Java 工程師的技術小站，作者黃小斜，專注 Java 相關技術：SSM、SpringBoot、MySQL、分散式、中介軟體、叢集、Linux、網路、多執行緒，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

**Java工程師必備學習資源:** 一些Java工程師常用學習資源，關注公眾號後，後臺回覆關鍵字 **“Java”** 即可免費無套路獲取。

![我的公眾號](https://img-blog.csdnimg.cn/20190805090108984.jpg)

### 個人公眾號：黃小斜

黃小斜是跨考軟體工程的 985 碩士，自學 Java 兩年，拿到了 BAT 等近十家大廠 offer，從技術小白成長為阿里工程師。

作者專注於 JAVA 後端技術棧，熱衷於分享程式設計師乾貨、學習經驗、求職心得和程式人生，目前黃小斜的CSDN部落格有百萬+訪問量，知乎粉絲2W+，全網已有10W+讀者。

黃小斜是一個斜槓青年，堅持學習和寫作，相信終身學習的力量，希望和更多的程式設計師交朋友，一起進步和成長！關注公眾號【黃小斜】後回覆【原創電子書】即可領取我原創的電子書《菜鳥程式設計師修煉手冊：從技術小白到阿里巴巴Java工程師》

**程式設計師3T技術學習資源：** 一些程式設計師學習技術的資源大禮包，關注公眾號後，後臺回覆關鍵字 **“資料”** 即可免費無套路獲取。

![](https://img-blog.csdnimg.cn/20190829222750556.jpg)

</developer></developer></developer></developer></developer></developer></developer></developer></developer></developer></developer></developer></s.length></integer></integer>

Java集合詳解3：一文讀懂Iterator，fail-fast機制與比較器

相關文章