本文目錄
1 Iterator
1.1 Iterator定義
Java JDK中Iterator定義如下：
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接口，看他是如何來進行實現的。
1.2 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()來判斷、獲取下一個元素，至於具體的內部實現我們就不用關心了。
1.3 各個集合的Iterator的實現
下面就ArrayList的Iterator實現來分析，其實如果我們理解了ArrayList、Hashset、TreeSet的數據結構，內部實現，對於他們是如何實現Iterator也會胸有成竹的。因爲ArrayList的內部實現採用數組，所以我們只需要記錄相應位置的索引即可，其方法的實現比較簡單。
（1）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();
}
}
2 fail-fast機制
2.1 什麼是fail-fast機制
在JDK的Collection中我們時常會看到類似於這樣的話：
例如，（1）ArrayList 中：注意，迭代器的快速失敗行爲無法得到保證，因爲一般來說，不可能對是否出現不同步併發修改做出任何硬性保證。快速失敗迭代器會盡最大努力拋出ConcurrentModificationException。 因此，爲提高這類迭代器的正確性而編寫一個依賴於此異常的程序是錯誤的做法：迭代器的快速失敗行爲應該僅用於檢測 bug。
（2）HashMap中：注意，迭代器的快速失敗行爲不能得到保證，一般來說，存在非同步的併發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力拋出 ConcurrentModificationException。因此，編寫依賴於此異常的程序的做法是錯誤的，正確做法是：迭代器的快速失敗行爲應該僅用於檢測程序錯誤。
在這兩段話中反覆地提到”快速失敗”。那麼何爲”快速失敗”機制呢？
“快速失敗”也就是fail-fast，它是Java集合的一種錯誤檢測機制。當多個線程對集合進行結構上的改變的操作時，有可能會產生fail-fast機制。
記住是有可能，而不是一定。例如：假設存在兩個線程（線程1、線程2），線程1通過Iterator在遍歷集合A中的元素，在某個時候線程2修改了集合A的結構（是結構上面的修改，而不是簡單的修改集合元素的內容），那麼這個時候程序就會拋出 ConcurrentModificationException異常，從而產生fail-fast機制。
2.2 fail-fast示例
示例如下：
public class FailFastTest {
private static ListInteger list = new ArrayList();
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();
}
}
}
}
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)
2.3 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機制。
2.4 fail-fast解決辦法
通過前面的實例、源碼分析，我想各位已經基本瞭解了fail-fast的機制，下面我就產生的原因提出解決方案。這裏有兩種解決方案：
方案一：在遍歷過程中所有涉及到改變modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList，這樣就可以解決。但是不推薦，因爲增刪造成的同步鎖可能會阻塞遍歷操作。
方案二：使用CopyOnWriteArrayList來替換ArrayList。推薦使用該方案。
CopyOnWriteArrayList爲何物？ArrayList 的一個線程安全的變體，其中所有可變操作（add、set 等等）都是通過對底層數組進行一次新的複製來實現的。 該類產生的開銷比較大，但是在兩種情況下，它非常適合使用。
（1）在不能或不想進行同步遍歷，但又需要從併發線程中排除衝突時。
（2）當遍歷操作的數量大大超過可變操作的數量時。遇到這兩種情況使用CopyOnWriteArrayList來替代ArrayList再適合不過了。那麼爲什麼CopyOnWriterArrayList可以替代ArrayList呢？
1）CopyOnWriterArrayList的無論是從數據結構、定義都和ArrayList一樣。它和ArrayList一樣，同樣是實現List接口，底層使用數組實現。在方法上也包含add、remove、clear、iterator等方法。
2）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也是相當有損耗的。
3 比較器Comparable 和 Comparator
Java 中爲我們提供了兩種比較機制：Comparable 和 Comparator。
3.1 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 等根據類的自然排序進行排序的集合容器時可以保證保存的數據的順序和想象中一致。
在有些場景下 equals 和 compareTo 結果要保持一致，這時候不重寫 equals，使用 Object.equals 方法得到的結果會有問題，比如說 HashMap.put() 方法，會先調用 key 的 equals 方法進行比較，然後才調用 compareTo。後面重寫 compareTo 時，要判斷某個相同時對比下一個屬性，把所有屬性都比較一次。
3.2 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;i++){
list.add(s[i]);
}
Collections.sort(list,new Comparator<Integer>(){
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方法。
排序和分組的區別在於: 排序時，兩個對象比較的結果有三種：大於，等於，小於。 分組時，兩個對象比較的結果只有兩種：等於(兩個對象屬於同一組)，不等於(兩個對象屬於不同組)
3.3 Java8中使用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語言都在不停的改進更新，想了解更多可到官網查找相關示例。
3.4 小結
（1）Java 中的兩種排序方式：
1）Comparable 自然排序。（實體類實現）
2）Comparator 是定製排序。（無法修改實體類時，直接在調用方創建）
3）同時存在時採用 Comparator（定製排序）的規則進行比較。
（2）對於一些普通的數據類型（比如 String, Integer, Double…），它們默認實現了Comparable 接口，實現了 compareTo 方法，我們可以直接使用。
（3）而對於一些自定義類，它們可能在不同情況下需要實現不同的比較策略，我們可以新創建 Comparator 接口，然後使用特定的Comparator 實現進行比較。
附言：
本文整理來源於網絡、博客等資源，僅做個人學習筆記複習所用。
如果對你學習有用，請點贊共同學習！
如有侵權，請聯繫我！