Java的Iterator，fail-fast機(jī)制與比較器怎么使用

本篇內(nèi)容主要講解“Java的Iterator，fail-fast機(jī)制與比較器怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實(shí)用性強(qiáng)。下面就讓小編來帶大家學(xué)習(xí)“Java的Iterator，fail-fast機(jī)制與比較器怎么使用”吧!

Iterator

迭代對于我們搞Java的來說絕對不陌生。我們常常使用JDK提供的迭代接口進(jìn)行Java集合的迭代。

Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            String string = iterator.next();
            //do something
        }

迭代其實(shí)我們可以簡單地理解為遍歷，是一個標(biāo)準(zhǔn)化遍歷各類容器里面的所有對象的方法類，它是一個很典型的設(shè)計(jì)模式。Iterator模式是用于遍歷集合類的標(biāo)準(zhǔn)訪問方法。

它可以把訪問邏輯從不同類型的集合類中抽象出來，從而避免向客戶端暴露集合的內(nèi)部結(jié)構(gòu)。 在沒有迭代器時我們都是這么進(jìn)行處理的。如下：

對于數(shù)組我們是使用下標(biāo)來進(jìn)行處理的:

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

對于ArrayList是這么處理的:

List<String> list = new ArrayList<String>();
   for(int i = 0 ; i < list.size() ;  i++){
      String string = list.get(i);
      //do something
   }

對于這兩種方式，我們總是都事先知道集合的內(nèi)部結(jié)構(gòu)，訪問代碼和集合本身是緊密耦合的，無法將訪問邏輯從集合類和客戶端代碼中分離出來。同時每一種集合對應(yīng)一種遍歷方法，客戶端代碼無法復(fù)用。

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

使得客戶端自身不需要來維護(hù)集合的內(nèi)部結(jié)構(gòu)，所有的內(nèi)部狀態(tài)都由Iterator來維護(hù)?？蛻舳藦牟恢苯雍图项惔蚪坏?，它總是控制Iterator，向它發(fā)送"向前"，"向后"，"取當(dāng)前元素"的命令，就可以間接遍歷整個集合。

上面只是對Iterator模式進(jìn)行簡單的說明，下面我們看看Java中Iterator接口，看他是如何來進(jìn)行實(shí)現(xiàn)的。

java.util.Iterator

在Java中Iterator為一個接口，它只提供了迭代了基本規(guī)則，在JDK中他是這樣定義的：對 collection 進(jìn)行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器與枚舉有兩點(diǎn)不同：

1、迭代器允許調(diào)用者利用定義良好的語義在迭代期間從迭代器所指向的 collection 移除元素。
2、方法名稱得到了改進(jìn)。

其接口定義如下：

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

其中：

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

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

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

==前面闡述了Iterator有一個很大的優(yōu)點(diǎn),就是我們不必知道集合的內(nèi)部結(jié)果,集合的內(nèi)部結(jié)構(gòu)、狀態(tài)由Iterator來維持，通過統(tǒng)一的方法hasNext()、next()來判斷、獲取下一個元素，至于具體的內(nèi)部實(shí)現(xiàn)我們就不用關(guān)心了。==

但是作為一個合格的程序員我們非常有必要來弄清楚Iterator的實(shí)現(xiàn)。下面就ArrayList的源碼進(jìn)行分析分析。

各個集合的Iterator的實(shí)現(xiàn)

下面就ArrayList的Iterator實(shí)現(xiàn)來分析，其實(shí)如果我們理解了ArrayList、Hashset、TreeSet的數(shù)據(jù)結(jié)構(gòu)，內(nèi)部實(shí)現(xiàn)，對于他們是如何實(shí)現(xiàn)Iterator也會胸有成竹的。因?yàn)锳rrayList的內(nèi)部實(shí)現(xiàn)采用數(shù)組，所以我們只需要記錄相應(yīng)位置的索引即可，其方法的實(shí)現(xiàn)比較簡單。

ArrayList的Iterator實(shí)現(xiàn)

在ArrayList內(nèi)部首先是定義一個內(nèi)部類Itr，該內(nèi)部類實(shí)現(xiàn)Iterator接口，如下：

private class Itr implements Iterator<E> {
    //do something
}
而ArrayList的iterator()方法實(shí)現(xiàn)：
public Iterator<E> iterator() {
        return new Itr();
    }

所以通過使用ArrayList.iterator()方法返回的是Itr()內(nèi)部類，所以現(xiàn)在我們需要關(guān)心的就是Itr()內(nèi)部類的實(shí)現(xiàn)：

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

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

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

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

對于next()實(shí)現(xiàn)其實(shí)也是比較簡單的，只要返回cursor索引位置處的元素即可，然后修改cursor、lastRet即可。

public E next() {
    checkForComodification();
    int i = cursor;    //記錄索引位置
    if (i >= size)    //如果獲取元素大于集合元素個數(shù)，則拋出異常
        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()主要用來判斷集合的修改次數(shù)是否合法，即用來判斷遍歷過程中集合是否被修改過。

。modCount用于記錄ArrayList集合的修改次數(shù)，初始化為0，，每當(dāng)集合被修改一次（結(jié)構(gòu)上面的修改，內(nèi)部update不算），如add、remove等方法，modCount + 1，所以如果modCount不變，則表示集合內(nèi)容沒有被修改。

該機(jī)制主要是用于實(shí)現(xiàn)ArrayList集合的快速失敗機(jī)制，在Java的集合中，較大一部分集合是存在快速失敗機(jī)制的，這里就不多說，后面會講到。

所以要保證在遍歷過程中不出錯誤，我們就應(yīng)該保證在遍歷過程中不會對集合產(chǎn)生結(jié)構(gòu)上的修改（當(dāng)然remove方法除外），出現(xiàn)了異常錯誤，我們就應(yīng)該認(rèn)真檢查程序是否出錯而不是catch后不做處理。

final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
對于remove()方法的是實(shí)現(xiàn)，它是調(diào)用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實(shí)現(xiàn)講解到這里，對于Hashset、TreeSet等集合的Iterator實(shí)現(xiàn)，各位如果感興趣可以繼續(xù)研究，個人認(rèn)為在研究這些集合的源碼之前，有必要對該集合的數(shù)據(jù)結(jié)構(gòu)有清晰的認(rèn)識，這樣會達(dá)到事半功倍的效果?。。?！

fail-fast機(jī)制

這部分參考http://cmsblogs.com/?p=1220

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

例如，ArrayList:

注意，迭代器的快速失敗行為無法得到保證，因?yàn)橐话銇碚f，不可能對是否出現(xiàn)不同步并發(fā)修改做出任何硬性保證?？焖偈〉鲿M最大努力拋出ConcurrentModificationException。 因此，為提高這類迭代器的正確性而編寫一個依賴于此異常的程序是錯誤的做法：迭代器的快速失敗行為應(yīng)該僅用于檢測 bug。

HashMap中：

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在非同步的并發(fā)修改時，不可能作出任何堅(jiān)決的保證?？焖偈〉鞅M最大努力拋出 ConcurrentModificationException。因此，編寫依賴于此異常的程序的做法是錯誤的，正確做法是：迭代器的快速失敗行為應(yīng)該僅用于檢測程序錯誤。

在這兩段話中反復(fù)地提到”快速失敗”。那么何為”快速失敗”機(jī)制呢？

“快速失敗”也就是fail-fast，它是Java集合的一種錯誤檢測機(jī)制。當(dāng)多個線程對集合進(jìn)行結(jié)構(gòu)上的改變的操作時，有可能會產(chǎn)生fail-fast機(jī)制。

記住是有可能，而不是一定。例如：假設(shè)存在兩個線程（線程1、線程2），線程1通過Iterator在遍歷集合A中的元素，在某個時候線程2修改了集合A的結(jié)構(gòu)（是結(jié)構(gòu)上面的修改，而不是簡單的修改集合元素的內(nèi)容），那么這個時候程序就會拋出 ConcurrentModificationException異常，從而產(chǎn)生fail-fast機(jī)制。

fail-fast示例

public class FailFastTest {
    private static List<Integer> list = new ArrayList<>();
    
    /**
     * @desc:線程one迭代list
     * @Project:test
     * @file:FailFastTest.java
     * @Authro:chenssy
     * @data:2014年7月26日
     */
    private static class threadOne extends Thread{
        public void run() {
            Iterator<Integer> 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:當(dāng)i == 3時，修改list
     * @Project:test
     * @file:FailFastTest.java
     * @Authro:chenssy
     * @data:2014年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();
    }
}

運(yùn)行結(jié)果：

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.java:23)

fail-fast產(chǎn)生原因

通過上面的示例和講解，我初步知道fail-fast產(chǎn)生的原因就在于程序在對 collection 進(jìn)行迭代時，某個線程對該 collection 在結(jié)構(gòu)上對其做了修改，這時迭代器就會拋出 ConcurrentModificationException 異常信息，從而產(chǎn)生 fail-fast。

要了解fail-fast機(jī)制，我們首先要對ConcurrentModificationException 異常有所了解。當(dāng)方法檢測到對象的并發(fā)修改，但不允許這種修改時就拋出該異常。同時需要注意的是，該異常不會始終指出對象已經(jīng)由不同線程并發(fā)修改，如果單線程違反了規(guī)則，同樣也有可能會拋出改異常。

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

從前面我們知道fail-fast是在操作迭代器時產(chǎn)生的。現(xiàn)在我們來看看ArrayList中迭代器的源代碼：

private class Itr implements Iterator<E> {
        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();
        }
    }

從上面的源代碼我們可以看出，迭代器在調(diào)用next()、remove()方法時都是調(diào)用checkForComodification()方法，該方法主要就是檢測modCount == expectedModCount ? 若不等則拋出ConcurrentModificationException 異常，從而產(chǎn)生fail-fast機(jī)制。所以要弄清楚為什么會產(chǎn)生fail-fast機(jī)制我們就必須要用弄明白為什么modCount != expectedModCount ，他們的值在什么時候發(fā)生改變的。

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

protected transient int modCount = 0; 那么他什么時候因?yàn)槭裁丛蚨l(fā)生改變呢？請看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元素的個數(shù)的方法都會導(dǎo)致modCount的改變。

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

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

線程A繼續(xù)遍歷執(zhí)行next方法時，通告checkForComodification方法發(fā)現(xiàn)expectedModCount = N ，而modCount = N + 1，兩者不等，這時就拋出ConcurrentModificationException 異常，從而產(chǎn)生fail-fast機(jī)制。

所以，直到這里我們已經(jīng)完全了解了fail-fast產(chǎn)生的根本原因了。知道了原因就好找解決辦法了。

三、fail-fast解決辦法

通過前面的實(shí)例、源碼分析，我想各位已經(jīng)基本了解了fail-fast的機(jī)制，下面我就產(chǎn)生的原因提出解決方案。這里有兩種解決方案：

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

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

CopyOnWriteArrayList為何物？ArrayList 的一個線程安全的變體，其中所有可變操作（add、set 等等）都是通過對底層數(shù)組進(jìn)行一次新的復(fù)制來實(shí)現(xiàn)的。 該類產(chǎn)生的開銷比較大，但是在兩種情況下，它非常適合使用。

1：在不能或不想進(jìn)行同步遍歷，但又需要從并發(fā)線程中排除沖突時。

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

第一、CopyOnWriterArrayList的無論是從數(shù)據(jù)結(jié)構(gòu)、定義都和ArrayList一樣。它和ArrayList一樣，同樣是實(shí)現(xiàn)List接口，底層使用數(shù)組實(shí)現(xiàn)。在方法上也包含add、remove、clear、iterator等方法。

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

private static class COWIterator implements ListIterator { /** 省略此處代碼 */ 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方法有一個最大的不同點(diǎn)就在于，下面三句代碼：

Object[] arrayOfObject2 = Arrays.copyOf(arrayOfObject1, i + 1);
arrayOfObject2[i] = paramE;
setArray(arrayOfObject2);

就是這三句代碼使得CopyOnWriterArrayList不會拋ConcurrentModificationException異常。他們所展現(xiàn)的魅力就在于copy原來的array，再在copy數(shù)組上進(jìn)行add操作，這樣做就完全不會影響COWIterator中的array了。

所以CopyOnWriterArrayList所代表的核心概念就是：任何對array在結(jié)構(gòu)上有所改變的操作（add、remove、clear等），CopyOnWriterArrayList都會copy現(xiàn)有的數(shù)據(jù)，再在copy的數(shù)據(jù)上修改，這樣就不會影響COWIterator中的數(shù)據(jù)了，修改完成之后改變原有數(shù)據(jù)的引用即可。同時這樣造成的代價就是產(chǎn)生大量的對象，同時數(shù)組的copy也是相當(dāng)有損耗的。

Comparable 和 Comparator

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

Comparable

Comparable 在 java.lang包下，是一個接口，內(nèi)部只有一個方法 compareTo()：

public interface Comparable<T> {
    public int compareTo(T o);
}

Comparable 可以讓實(shí)現(xiàn)它的類的對象進(jìn)行比較，具體的比較規(guī)則是按照 compareTo 方法中的規(guī)則進(jìn)行。這種順序稱為 自然順序。

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

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

注意：

1.由于 null 不是一個類，也不是一個對象，因此在重寫 compareTo 方法時應(yīng)該注意 e.compareTo(null) 的情況，即使 e.equals(null) 返回 false，compareTo 方法也應(yīng)該主動拋出一個空指針異常 NullPointerException。

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

舉個例子，如果你往一個 SortedSet 中先后添加兩個對象 a 和 b，a b 滿足 (!a.equals(b) && a.compareTo(b) == 0)，同時也沒有另外指定個 Comparator，那當(dāng)你添加完 a 再添加 b 時會添加失敗返回 false, SortedSet 的 size 也不會增加，因?yàn)樵?SortedSet 看來它們是相同的，而 SortedSet 中是不允許重復(fù)的。

實(shí)際上所有實(shí)現(xiàn)了 Comparable 接口的 Java 核心類的結(jié)果都和 equlas 方法保持一致。 實(shí)現(xiàn)了 Comparable 接口的 List 或則數(shù)組可以使用 Collections.sort() 或者 Arrays.sort() 方法進(jìn)行排序。

實(shí)現(xiàn)了 Comparable 接口的對象才能夠直接被用作 SortedMap (SortedSet) 的 key，要不然得在外邊指定 Comparator 排序規(guī)則。

因此自己定義的類如果想要使用有序的集合類，需要實(shí)現(xiàn) Comparable 接口，比如：

**

• description: 測試用的實(shí)體類 書, 實(shí)現(xiàn)了 Comparable 接口，自然排序

• author: shixinzhang

• data: 10/5/2016 */ 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; }

  /**

  }

  /**

  @Override public String toString() { return "BookBean{" + "name='" + name + ''' + ", count=" + count + '}'; }

  /**

• 當(dāng)向 TreeSet 中添加 BookBean 時，會調(diào)用這個方法進(jìn)行排序

• @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){   //當(dāng)書價一致時，再對比書名。 保證所有屬性比較一遍
       result = getName().compareTo(anotherBook.getName());
   }
   return result;

  } // 一樣就返回 0 return 0; }

• 重寫 hashCode 的計(jì)算方法

• 根據(jù)所有屬性進(jìn)行 迭代計(jì)算，避免重復(fù)

• 計(jì)算 hashCode 時 計(jì)算因子 31 見得很多，是一個質(zhì)數(shù)，不能再被除

• @return */ @Override public int hashCode() { //調(diào)用 String 的 hashCode(), 唯一表示一個字符串內(nèi)容 int result = getName().hashCode(); //乘以 31, 再加上 count result = 31 * result + getCount(); return result; }

• 重寫 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());

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

這里我想表達(dá)的是在有些場景下 equals 和 compareTo 結(jié)果要保持一致，這時候不重寫 equals，使用 Object.equals 方法得到的結(jié)果會有問題，比如說 HashMap.put() 方法，會先調(diào)用 key 的 equals 方法進(jìn)行比較，然后才調(diào)用 compareTo。

后面重寫 compareTo 時，要判斷某個相同時對比下一個屬性，把所有屬性都比較一次。

Comparable

Comparable 接口屬于 Java 集合框架的一部分。

Comparator 定制排序

Comparator 在 java.util 包下，也是一個接口，JDK 1.8 以前只有兩個方法：

public interface Comparator<T> {
    public int compare(T lhs, T rhs);
    public boolean equals(Object object);
}

JDK 1.8 以后又新增了很多方法：

基本上都是跟 Function 相關(guān)的，這里暫不介紹 1.8 新增的。

從上面內(nèi)容可知使用自然排序需要類實(shí)現(xiàn) Comparable，并且在內(nèi)部重寫 comparaTo 方法。

而 Comparator 則是在外部制定排序規(guī)則，然后作為排序策略參數(shù)傳遞給某些類，比如 Collections.sort(), Arrays.sort(), 或者一些內(nèi)部有序的集合（比如 SortedSet，SortedMap 等）。

Comparator的使用方法 使用方式主要分三步：

創(chuàng)建一個 Comparator 接口的實(shí)現(xiàn)類，并賦值給一個對象 在 compare 方法中針對自定義類寫排序規(guī)則 將 Comparator 對象作為參數(shù)傳遞給 排序類的某個方法 向排序類中添加 compare 方法中使用的自定義類 舉個例子：

// 1.創(chuàng)建一個實(shí)現(xiàn) Comparator 接口的對象
Comparator comparator = new Comparator() {
    @Override
    public int compare(Object object1, Object object2) {
        if (object1 instanceof NewBookBean && object2 instanceof NewBookBean){
            NewBookBean newBookBean = (NewBookBean) object1;
            NewBookBean newBookBean1 = (NewBookBean) object2;
            //具體比較方法參照 自然排序的 compareTo 方法，這里只舉個栗子
            return newBookBean.getCount() - newBookBean1.getCount();
        }
        return 0;
    }
};
//2.將此對象作為形參傳遞給 TreeSet 的構(gòu)造器中
TreeSet treeSet = new TreeSet(comparator);
//3.向 TreeSet 中添加 步驟 1 中 compare 方法中設(shè)計(jì)的類的對象
treeSet.add(new NewBookBean("A",34));
treeSet.add(new NewBookBean("S",1));
treeSet.add( new NewBookBean("V",46));
treeSet.add( new NewBookBean("Q",26));

其實(shí)可以看到，Comparator 的使用是一種策略模式。 排序類中持有一個 Comparator 接口的引用：

Comparator<? super K> comparator;

而我們可以傳入各種自定義排序規(guī)則的 Comparator 實(shí)現(xiàn)類，對同樣的類制定不同的排序策略。

到此，相信大家對“Java的Iterator，fail-fast機(jī)制與比較器怎么使用”有了更深的了解，不妨來實(shí)際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！