?TreeMap和TreeSet在排序時主要通過實(shí)現(xiàn)Comparable接口或使用Comparator對象進(jìn)行比較。?

在TreeMap中，元素的排序是通過實(shí)現(xiàn)元素的Comparable接口或者使用Comparator對象來實(shí)現(xiàn)的。如果元素實(shí)現(xiàn)了Comparable接口，則使用元素的compareTo()方法進(jìn)行比較；如果沒有實(shí)現(xiàn)Comparable接口，則需要提供一個Comparator對象來進(jìn)行比較。比較的結(jié)果決定了元素在TreeMap中的排序順序?。

在TreeSet中，元素的排序同樣是通過實(shí)現(xiàn)元素的Comparable接口或者使用Comparator對象來實(shí)現(xiàn)的。如果元素實(shí)現(xiàn)了Comparable接口，則使用元素的compareTo()方法進(jìn)行比較；如果沒有實(shí)現(xiàn)Comparable接口，則需要提供一個Comparator對象來進(jìn)行比較。比較的結(jié)果決定了元素在TreeSet中的排序順序?。

Collections工具類中的sort()方法也通過實(shí)現(xiàn)元素的Comparable接口或者使用Comparator對象來進(jìn)行排序。如果元素實(shí)現(xiàn)了Comparable接口，則使用元素的compareTo()方法進(jìn)行比較；如果沒有實(shí)現(xiàn)Comparable接口，則需要提供一個Comparator對象來進(jìn)行比較。比較的結(jié)果決定了元素在排序后的順序?.

ArrayList和LinkedList都是Java集合框架中的一部分，它們實(shí)現(xiàn)了List接口，用于存儲元素的動態(tài)數(shù)組。然而，它們在內(nèi)部實(shí)現(xiàn)、效率、以及 操作特點(diǎn)上有一些顯著的區(qū)別。

?（1）內(nèi)部實(shí)現(xiàn) ArrayList是基于數(shù)組實(shí)現(xiàn)的，其內(nèi)部維護(hù)了一個動態(tài)數(shù)組來存儲元素。數(shù)組是一塊連續(xù)的內(nèi)存空間，因此ArrayList在隨機(jī)訪問元素時非常高 效，時間復(fù)雜度為O(1)。然而，當(dāng)添加或刪除元素時，如果數(shù)組已滿或需要移動元素，可能需要進(jìn)行擴(kuò)容或數(shù)據(jù)移動操作，這可能會降低效 率。 LinkedList則是基于鏈表實(shí)現(xiàn)的，其內(nèi)部元素是通過節(jié)點(diǎn)（Node）連接在一起的。每個節(jié)點(diǎn)包含實(shí)際的數(shù)據(jù)以及指向下一個和上一個節(jié)點(diǎn)的 指針。因此，LinkedList在內(nèi)存中的存儲不是連續(xù)的。這種結(jié)構(gòu)使得LinkedList在添加或刪除元素時效率較高，因?yàn)橹恍枰薷南嚓P(guān)節(jié)點(diǎn)的指 針，而不需要移動大量數(shù)據(jù)。然而，隨機(jī)訪問元素時，LinkedList需要從頭或尾開始遍歷，效率較低。

（2）效率 當(dāng)需要頻繁地進(jìn)行隨機(jī)訪問元素（如通過索引獲取元素）時，ArrayList通常比LinkedList更高效，因?yàn)锳rrayList可以直接通過索引定位到元 素。 而在添加或刪除元素時，LinkedList通常比ArrayList更高效，因?yàn)長inkedList只需要修改相關(guān)節(jié)點(diǎn)的指針，而不需要移動其他元素。

（3）控件開銷 ArrayList的主要控件開銷在于需要在其內(nèi)部數(shù)組中預(yù)留一定的空間以存儲元素。當(dāng)元素數(shù)量超出當(dāng)前容量時，ArrayList會自動進(jìn)行擴(kuò)容，以 適應(yīng)更多的元素。這種擴(kuò)容操作可能會導(dǎo)致一定的性能開銷。 LinkedList的主要控件開銷在于需要存儲每個節(jié)點(diǎn)的信息以及節(jié)點(diǎn)之間的指針信息。這增加了額外的內(nèi)存開銷，但使得在鏈表中間添加或刪 除元素的操作變得高效。

（4）線程安全 ArrayList和LinkedList都不是線程安全的。如果在多線程環(huán)境下使用，需要手動進(jìn)行同步處理或者使用線程安全的集合類，如 Collections.synchronizedList()或CopyOnWriteArrayList。 綜上所述，ArrayList和LinkedList各有其優(yōu)勢和適用場景。在選擇使用哪種集合時，應(yīng)根據(jù)具體的應(yīng)用需求和性能要求來做出決策。如果需 要頻繁地進(jìn)行隨機(jī)訪問元素，ArrayList可能更合適；而如果需要頻繁地進(jìn)行添加或刪除元素的操作，LinkedList可能更合適。

ArrayList和Vector都是基于數(shù)組實(shí)現(xiàn)的List集合類，它們提供了動態(tài)數(shù)組的功能，可以根據(jù)需要自動調(diào)整大小以存儲對象。

Vector的公共方法大多帶有synchronized關(guān)鍵字，確保了方法是同步的，因此Vector是線程安全的。而ArrayList沒有這樣的同步措施，所以 它是線程不安全的。

?由于Vector的方法是同步的，因此在多線程環(huán)境下會涉及鎖的獲取和釋放，這可能導(dǎo)致性能上的開銷。相比之下，ArrayList由于沒有額外的 同步開銷，通常運(yùn)行得更快。 當(dāng)?shù)讓訑?shù)組容量不足以容納新元素時，ArrayList會在原有基礎(chǔ)上擴(kuò)展約0.5倍的容量，而Vector則擴(kuò)展一倍的容量。這意味著在頻繁進(jìn)行大量 添加操作的情況下，ArrayList可能會有更高的效率。

（1）隊(duì)列先進(jìn)先出，棧先進(jìn)后出。

（2）遍歷數(shù)據(jù)速度不同。

?棧只能從頭部取數(shù)據(jù) 也就最先放入的需要遍歷整個棧最后才能取出來，而且在遍歷數(shù)據(jù)的時候還得為數(shù)據(jù)開辟臨時空間，保持?jǐn)?shù)據(jù)在遍歷前 的一致性； 隊(duì)列則不同，他基于地址指針進(jìn)行遍歷，而且可以從頭或尾部開始遍歷，但不能同時遍歷，無需開辟臨時空間，因?yàn)樵诒闅v的過程中不影像 數(shù)據(jù)結(jié)構(gòu)，速度要快的多。

Queue以及Deque都是繼承于Collection，Deque是Queue的子接口。

Queue是FIFO的單向隊(duì)列，Deque是雙向隊(duì)列。

Queue有一個直接子類PriorityQueue，而Deque中直接子類有兩個：LinkedList以及ArrayDeque。 PriorityQueue的底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組，而無邊界的形容，那么指明了PriorityQueue是自帶擴(kuò)容機(jī)制的。 ArrayDeque是無初始容量的雙端隊(duì)列，LinkedList則是雙向鏈表。

PriorityQueue可以作為堆使用，而且可以根據(jù)傳入的Comparator實(shí)現(xiàn)大小的調(diào)整，會是一個很好的選擇。 ArrayDeque通常作為?；蜿?duì)列使用，但是棧的效率不如LinkedList高。 LinkedList通常作為?；蜿?duì)列使用，但是隊(duì)列的效率不如ArrayQueue高。

（1）offer()和add()區(qū)別： 增加新項(xiàng)時，如果隊(duì)列滿了，add會拋出異常，offer返回false。

（2）poll()和remove()區(qū)別： poll()和remove()都是從隊(duì)列中刪除第一個元素，remove拋出異常，poll返回null。

（3）peek()和element（）區(qū)別： peek()和element（）用于查詢隊(duì)列頭部元素，為空時element拋出異常，peek返回null。

優(yōu)先隊(duì)列中的元素可以按照任意的順序插入，但會按照有序的順序獲取。

優(yōu)先隊(duì)列常用結(jié)構(gòu)是PriorityQueue和ArrayDeque。

也就是在調(diào)用remove時，總是刪除隊(duì)列中最小的元素。

優(yōu)先隊(duì)列使用堆作為存儲數(shù)據(jù)結(jié)構(gòu)，堆是一個自組織的二叉樹，其添加和刪除操作會讓最小的元素移動到根，而不必花費(fèi)時間對元素進(jìn)行排 序。 優(yōu)先隊(duì)列的主要用途是調(diào)度。每個任務(wù)有一個優(yōu)先級，任務(wù)以隨機(jī)順序插入到隊(duì)列中，每當(dāng)啟動一個新的任務(wù)時，將從隊(duì)列中刪除優(yōu)先級最 高的任務(wù)。

雙端隊(duì)列是一種特殊的隊(duì)列，它的兩端都可以進(jìn)行插入和刪除操作。這種隊(duì)列的實(shí)現(xiàn)方式是使用兩個指針，一個指針指向隊(duì)列的頭部，另一 個指針指向隊(duì)列的尾部。當(dāng)需要插入或刪除元素時，只需要移動指針即可。

雙端隊(duì)列的主要優(yōu)點(diǎn)是可以在隊(duì)列的兩端進(jìn)行操作，因此具有較高的效率。此外，雙端隊(duì)列還具有一些其他的優(yōu)點(diǎn)，例如可以在隊(duì)列的兩端 進(jìn)行查詢操作，因此具有較高的查詢效率。

雙端隊(duì)列的缺點(diǎn)是插入和刪除操作的時間復(fù)雜度都是O(1)，因此在處理大量數(shù)據(jù)時可能會導(dǎo)致性能問題。此外，雙端隊(duì)列的空間復(fù)雜度也是 O(1)，因此在插入和刪除元素時需要使用額外的空間。

?CopyOnWriteArrayList是Java并發(fā)包java.util.concurrent下提供的一個線程安全的ArrayList實(shí)現(xiàn)，它是寫時復(fù)制（Copy-On-Write）的容 器。

?CopyOnWriteArrayList的核心特性在于，當(dāng)修改容器（例如添加、刪除元素）時，不是直接修改當(dāng)前容器，而是先復(fù)制當(dāng)前容器的副本，然 后在副本上進(jìn)行修改。修改完成后，再將原容器的引用指向新的容器。這種策略使得讀操作可以完全不用加鎖，因此讀取性能極高。同時， 寫入操作也不會阻塞讀取操作，只有寫入和寫入之間需要進(jìn)行同步等待。

?由于CopyOnWriteArrayList的這些特性，它特別適用于以下場景：

1. 讀多寫少的場景：當(dāng)對數(shù)據(jù)的讀操作次數(shù)遠(yuǎn)遠(yuǎn)高于寫操作時，使用CopyOnWriteArrayList可以有效提升系統(tǒng)性能。因?yàn)槊看涡薷牟僮?都會創(chuàng)建底層數(shù)組的副本，從而避免了讀取操作受到寫入操作的干擾。

2. 數(shù)據(jù)更新要求不頻繁的場景：由于每次添加、修改或刪除列表中的元素時，CopyOnWriteArrayList都需要重新創(chuàng)建一個新的底層數(shù) 組，因此在實(shí)現(xiàn)上會消耗更多的內(nèi)存空間。因此，它更適用于數(shù)據(jù)更新不頻繁的場景。

3. 互斥訪問數(shù)據(jù)不方便的場景：在多線程環(huán)境下，如果需要對一個ArrayList實(shí)例進(jìn)行訪問，通常需要加鎖以保證數(shù)據(jù)一致性。但在某些場 景下，加鎖可能會給程序帶來額外的復(fù)雜度和延遲。此時，可以考慮使用CopyOnWriteArrayList。

4. 需要保證數(shù)據(jù)一致性的場景：由于每個線程都在自己的副本上進(jìn)行操作，因此不存在讀取過程中數(shù)據(jù)被其他線程修改的問題，從而保證 了數(shù)據(jù)的一致性。

（1）內(nèi)存占用問題 由于CopyOnWriteArrayList的寫時復(fù)制機(jī)制，當(dāng)進(jìn)行寫操作時，內(nèi)存中會同時駐扎兩個對象的內(nèi)存，舊的對象和新寫入的對象。在復(fù)制時只 復(fù)制容器里的引用，在寫時才會創(chuàng)建新對象添加到新容器里，而舊容器的對象還在使用，所以有兩份對象內(nèi)存。

（2）數(shù)據(jù)一致性問題 CopyOnWriteArrayList只能保證數(shù)據(jù)的最終一致性，不能保證數(shù)據(jù)的實(shí)時一致性。因?yàn)閺?fù)制和操作元素需要一些時間，所以會有延遲。如果 希望寫入的數(shù)據(jù)馬上能讀到，要求數(shù)據(jù)強(qiáng)一致性的話，建議不要使用CopyOnWriteArrayList。

（3）線程安全 CopyOnWriteArrayList是寫同步，讀非同步的。多個線程對CopyOnWriteArrayList進(jìn)行寫操作是線程安全的，但是在讀操作時是非線程安 全的。如果在for循環(huán)中使用下標(biāo)的方式去讀取數(shù)據(jù)，可能會報錯ArrayIndexOutOfBoundsException。

（4）不支持add()、set()、remove()方法 CopyOnWriteArrayList的迭代器實(shí)現(xiàn)了ListIterator接口，但是add()、set()、remove()方法都直接拋出了UnsupportedOperationException 異常，所以應(yīng)該避免使用迭代器的這幾個方法。

從數(shù)組中間刪除一個元素開銷很大，其原因是向數(shù)組中插入元素時，此元素之后的所有元素都要向后端移動，刪除時也是，數(shù)組中位于被刪 除元素之后的所有元素都要向數(shù)組的前端移動。

此時，在Java中，可以通過鏈表解決這個問題。 數(shù)組是在連續(xù)的存儲位置上存放對象引用，而鏈表則是將每個對象存放在單獨(dú)的鏈接link中。每個鏈接還存放著序列中下一個鏈接的引用。 在Java中，所有的鏈表都是雙向鏈接，即每個鏈接還存儲前驅(qū)的引用。

散列表，也叫哈希表，是根據(jù)關(guān)鍵碼值(Key value)直接進(jìn)行訪問的數(shù)據(jù)結(jié)構(gòu)。它通過把關(guān)鍵碼值映射到表中一個位置來訪問記錄，以此來加快查找的速度。這個映射函數(shù)就是散列函數(shù)，存放記錄的數(shù)組就是散列表。

在Java中，散列表通常由HashMap和HashSet實(shí)現(xiàn)。HashMap存儲鍵值對，HashSet存儲獨(dú)立的元素。散列表的實(shí)現(xiàn)原理基于散列函數(shù)和處理沖突的方法。

Java中HashMap的實(shí)現(xiàn)原理：

1. 使用一個Node數(shù)組作為存儲數(shù)據(jù)的數(shù)據(jù)結(jié)構(gòu)。
2. 通過key的hashCode()方法計算出哈希值，然后通過某種散列算法轉(zhuǎn)換成數(shù)組下標(biāo)。
3. 如果出現(xiàn)不同key計算出相同數(shù)組下標(biāo)的情況，則采用鏈表的方式將Node鏈接在一起。
4. 如果鏈表長度超過閾值（鏈表轉(zhuǎn)紅黑樹的閾值），則將鏈表轉(zhuǎn)換為紅黑樹。
5. 在插入和查詢時，重復(fù)上述步驟。

   
   public class HashMap<K, V> {// 存儲數(shù)據(jù)的數(shù)組Node<K, V>[] table;// 閾值，數(shù)組大小超過這個值時會進(jìn)行擴(kuò)容int threshold;// 加載因子float loadFactor;public V put(K key, V value) {// 計算key的hash值int hash = hash(key.hashCode());// 轉(zhuǎn)換為數(shù)組下標(biāo)int index = indexFor(hash, table.length);// 遍歷鏈表，如果已存在相同的key，則替換valuefor (Node<K, V> e = table[index]; e != null; e = e.next) {if (e.key.equals(key)) {V oldValue = e.value;e.value = value;return oldValue;}}// 如果key不存在，則添加到鏈表的頭部table[index] = new Node<>(key, value, table[index]);// 檢查是否需要擴(kuò)容if (size++ >= threshold)resize(2 * table.length);return null;}public V get(K key) {// 計算key的hash值int hash = hash(key.hashCode());// 轉(zhuǎn)換為數(shù)組下標(biāo)int index = indexFor(hash, table.length);// 遍歷鏈表，查找key對應(yīng)的valuefor (Node<K, V> e = table[index]; e != null; e = e.next) {if (e.key.equals(key))return e.value;}return null;}// 散列算法static int hash(int h) {h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);}// 計算數(shù)組下標(biāo)static int indexFor(int h, int length) {return h & (length - 1);}// 擴(kuò)容方法void resize(int newCapacity) {// ...}// 內(nèi)部類Node，表示鏈表節(jié)點(diǎn)static class Node<K, V> {final K key;V value;Node<K, V> next;Node(K key, V value, Node<K, V> next) {this.key = key;this.value = value;this.next = next;}}
   }

?Java中的映射視圖是指一種將Map轉(zhuǎn)換為Set或Collection的機(jī)制，以便于更方便地操作Map中的元素。

1. keySet()：返回包含Map中所有鍵的Set；

2. values()：返回包含Map中所有值的Collection；

3. entrySet()：返回包含Map中所有鍵值對的Set；

通過這些映射視圖，可以方便地遍歷Map中的元素、檢查某個鍵是否存在、刪除指定鍵等操作。 在使用時需要注意，映射視圖只是一個視圖，即對原Map進(jìn)行的修改會反映到相應(yīng)的映射視圖中，反之亦然，因此要謹(jǐn)慎使用。 另外，由于映射視圖是基于Map實(shí)現(xiàn)的，因此對映射視圖的修改也可能影響到原Map中的元素。

以下是一個簡單的例子，展示了如何使用HashMap來添加和獲取鍵值對：

import java.util.HashMap;public class MappingViewExample {public static void main(String[] args) {// 創(chuàng)建一個HashMapHashMap<String, Integer> map = new HashMap<>();// 添加鍵值對map.put("key1", 1);map.put("key2", 2);map.put("key3", 3);// 獲取并打印鍵為"key2"的值Integer value = map.get("key2");System.out.println("key2的值為: " + value);// 刪除鍵為"key2"的鍵值對map.remove("key2");// 檢查鍵"key2"是否存在if(map.containsKey("key2")) {System.out.println("key2存在");} else {System.out.println("key2不存在");}}
}

Java中的弱散列映射指的是一種特殊的Map實(shí)現(xiàn)，即WeakHashMap類。和普通HashMap不同WeakHashMap中的鍵是弱引用，即當(dāng)某個 鍵不再被外部對象引用時，該鍵及其對應(yīng)的值會被自動清除掉，以避免內(nèi)存泄漏問題。

通過使用WeakHashMap，可以將某些對象與其他應(yīng)用邏輯分離開來，使得它們的生命周期僅由其它對象的引用決定，當(dāng)沒有任何對象引用 時，這些對象會被自動清除，從而釋放系統(tǒng)資源。在Java中，常用WeakHashMap來實(shí)現(xiàn)緩存、事件通知等場景。需要注意的是，由于弱引 用的存在，WeakHashMap無法保證元素的順序，因此在遍歷時應(yīng)該謹(jǐn)慎。

WeakHashMap是一種基于紅黑樹實(shí)現(xiàn)的有序映射，它的常用方法包括：

?1. put(K key, V value)：將一個鍵值對添加到弱散列映射中；

?2. get(K key)：返回一個鍵值對，如果鍵不存在則返回null；

3. remove(K key)：從弱散列映射中刪除一個鍵值對；

4. containsKey(K key)：檢查一個鍵是否存在于弱散列映射中；

5. size()：返回弱散列映射中鍵值對的數(shù)量； 這些方法都是基于紅黑樹實(shí)現(xiàn)的，因此它們的時間復(fù)雜度都是O(log n)，其中n是Map中元素的數(shù)量。

import java.util.WeakHashMap;
import java.util.Map;public class WeakHashMapExample {public static void main(String[] args) {Map<String, String> weakHashMap = new WeakHashMap<>();// 添加鍵值對weakHashMap.put("key1", "value1");weakHashMap.put("key2", "value2");// 檢查WeakHashMap的大小System.out.println("WeakHashMap Size: " + weakHashMap.size());// 做一些操作來觸發(fā)垃圾收集器System.gc(); // 顯式調(diào)用垃圾收集器// 再次檢查WeakHashMap的大小System.out.println("WeakHashMap Size after GC: " + weakHashMap.size());}}

Java中的鏈接散列映射指的是HashMap和LinkedHashMap這兩個鍵值對映射集合實(shí)現(xiàn)類。它們都是基于哈希表實(shí)現(xiàn)的，鏈?zhǔn)缴⒘惺墙鉀Q哈 希沖突的一種方法。

具體來說，HashMap和LinkedHashMap內(nèi)部使用哈希表來存儲鍵值對，當(dāng)多個鍵經(jīng)過哈希函數(shù)計算后產(chǎn)生同一個索引位置時，就會產(chǎn)生哈 希沖突。為了解決哈希沖突，HashMap和LinkedHashMap使用鏈?zhǔn)缴⒘屑夹g(shù)，即在哈希表每個索引位置上維護(hù)一個鏈表，將所有哈希值相 同的鍵值對存放在同一個鏈表中，從而實(shí)現(xiàn)快速查找和添加元素。

HashMap和LinkedHashMap的區(qū)別在于，前者是無序鍵值對集合，而后者是有序鍵值對集合。具體來說，LinkedHashMap內(nèi)部使用一個雙 向鏈表來維護(hù)鍵值對的插入順序，因此遍歷LinkedHashMap時可以按照鍵值對插入的順序進(jìn)行。需要注意的是，在使用HashMap和 LinkedHashMap時，應(yīng)根據(jù)具體的業(yè)務(wù)需求和性能要求選擇合適的實(shí)現(xiàn)類。

Java中的鏈接散列集指的是HashSet和LinkedHashSet這兩個集合實(shí)現(xiàn)類。它們都是基于哈希表（Hash Table）實(shí)現(xiàn)的，鏈?zhǔn)缴⒘惺墙鉀Q哈希沖突的一種方法。

HashSet和LinkedHashSet內(nèi)部使用哈希表來存儲元素，當(dāng)多個元素經(jīng)過哈希函數(shù)計算后產(chǎn)生同一個索引位置時，就會產(chǎn)生哈希沖突。為了解決哈希沖突，HashSet和LinkedHashSet使用鏈?zhǔn)缴⒘屑夹g(shù)，即在哈希表每個索引位置上維護(hù)一個鏈表，將所有哈希值相同的元素存放在同一個鏈表中，從而實(shí)現(xiàn)快速查找和添加元素。

HashSet和LinkedHashSet的區(qū)別在于，前者是無序集合，而后者是有序集合。具體來說，LinkedHashSet內(nèi)部使用一個雙向鏈表來維護(hù)元素的插入順序，因此遍歷LinkedHashSet時可以按照元素插入的順序進(jìn)行。需要注意的是，在使用HashSet和LinkedHashSet時，應(yīng)根據(jù)具

體的業(yè)務(wù)需求和性能要求選擇合適的實(shí)現(xiàn)類。

LinkedHashMap的常用方法包括：

1. put(K key, V value)：將一個鍵值對添加到鏈接散列集中；

2. get(K key)：返回一個鍵值對，如果鍵不存在則返回null；

3. remove(K key)：從鏈接散列集中刪除一個鍵值對；

4. containsKey(K key)：檢查一個鍵是否存在于鏈接散列集中；

5. size()：返回鏈接散列集中鍵值對的數(shù)量；

這些方法都是基于鏈表實(shí)現(xiàn)的，因此它們的時間復(fù)雜度都是O(1)，其中n是Map中元素的數(shù)量。

Java中的枚舉集指的是基于枚舉類型實(shí)現(xiàn)的集合類，即EnumSet。

它是一個專門用于存儲枚舉類型值的高效集合實(shí)現(xiàn)類，可以實(shí)現(xiàn)基本操作（如添加、刪除、查找等）和集合運(yùn)算（如交、并、補(bǔ)等），同時還提供了高性能的迭代器，可以按照枚舉類型常量在內(nèi)存中出現(xiàn)的順序進(jìn)行遍歷。

EnumSet使用位向量（bit vector）實(shí)現(xiàn)，即將每個枚舉類型常量映射到一個二進(jìn)制位上，從而快速進(jìn)行集合運(yùn)算。由于EnumSet只能存儲枚舉類型值，因此它具有類型安全性、性能高效、空間利用率高等優(yōu)點(diǎn)。

EnumSet是一個抽象類，不能直接實(shí)例化，但可以通過EnumSet的靜態(tài)工廠方法創(chuàng)建實(shí)例，例如EnumSet.of()、EnumSet.range()等。此外，EnumSet也支持各種集合轉(zhuǎn)換操作，可以與其他集合實(shí)現(xiàn)類進(jìn)行互相轉(zhuǎn)換。

Java中的枚舉映射指的是基于枚舉類型實(shí)現(xiàn)的鍵值對集合類，即EnumMap。它是一個專門用于存儲枚舉類型作為鍵的鍵值對集合實(shí)現(xiàn)類，

可以實(shí)現(xiàn)基本操作（如添加、刪除、查找等）和集合運(yùn)算（如交、并、補(bǔ)等），同時還提供了高性能的迭代器，可以按照枚舉類型常量在內(nèi)存中出現(xiàn)的順序進(jìn)行遍歷。

EnumMap使用數(shù)組實(shí)現(xiàn)，數(shù)組的長度等于枚舉類型常量數(shù)目，每個位置上存儲的是該枚舉類型常量所對應(yīng)的值。由于EnumMap只能存儲枚舉類型作為鍵，因此它具有類型安全性、性能高效、空間利用率高等優(yōu)點(diǎn)。

需要注意的是，EnumMap也是一個抽象類，不能直接實(shí)例化，但可以通過EnumMap的構(gòu)造方法或靜態(tài)工廠方法創(chuàng)建實(shí)例，例如new EnumMap<>(MyEnum.class)、EnumMap.copyOf()等。此外，EnumMap也支持各種集合轉(zhuǎn)換操作，可以與其他集合實(shí)現(xiàn)類進(jìn)行互相轉(zhuǎn)換。

Comparator與Comparable在Java中都是用于比較對象大小的接口。

?Comparator與Comparable的主要區(qū)別在于它們的使用場景和實(shí)現(xiàn)方式。?

?Comparable?：Comparable是一個接口，定義在java.lang包中。實(shí)現(xiàn)Comparable接口的類必須實(shí)現(xiàn)compareTo方法，該方法用于比較當(dāng)前對象與另一個對象的大小。Comparable被稱為內(nèi)比較器，因?yàn)樗环庋b在實(shí)現(xiàn)它的類內(nèi)部。實(shí)現(xiàn)了Comparable接口的類可以直接使用Collections.sort()或Arrays.sort()等方法進(jìn)行排序。compareTo方法的返回值是int，有三種情況：負(fù)整數(shù)表示當(dāng)前對象小于比較對象，零表示相等，正整數(shù)表示當(dāng)前對象大于比較對象。

?Comparator?：Comparator也是一個接口，位于java.util包中。與Comparable不同，Comparator可以作為外比較器使用，即它不需要修改原類，而是通過實(shí)現(xiàn)Comparator接口來定義比較規(guī)則。Comparator接口定義了一個compare方法，用于比較兩個對象的大小。Comparator的返回值也是int，與Comparable的返回值相同，表示小于、等于或大于比較對象?。

?使用場景的區(qū)別?：

?Comparable?：適用于那些自然排序的場景，即對象本身具有明確的排序規(guī)則。例如，String類和Integer類都實(shí)現(xiàn)了Comparable接口，因此它們可以直接使用排序方法進(jìn)行排序。

?Comparator?：適用于那些沒有自然排序規(guī)則或者需要自定義排序規(guī)則的場景。通過實(shí)現(xiàn)Comparator接口，可以為任何類提供自定義的比較規(guī)則，而不需要修改類本身。這在處理復(fù)雜對象或需要多種排序方式時非常有用?。

為了方便的處理集合中的元素,Java中出現(xiàn)了一個對象,該對象提供了一些方法專門處理集合中的元素.例如刪除和獲取集合中的元素.該對象就叫做迭代器(Iterator)。

Iterator 接口源碼中的方法：

1. java.lang.Iterable 接口被 java.util.Collection 接口繼承，java.util.Collection 接口的 iterator() 方法返回一個 Iterator 對象

2. next() 方法獲得集合中的下一個元素

3. hasNext() 檢查集合中是否還有元素

4. remove() 方法將迭代器新返回的元素刪除

（1）ListIterator 繼承 Iterator

（2）ListIterator 比 Iterator多方法

add(E e) 將指定的元素插入列表，插入位置為迭代器當(dāng)前位置之前

set(E e) 迭代器返回的最后一個元素替換參數(shù)e

hasPrevious() 迭代器當(dāng)前位置，反向遍歷集合是否含有元素

previous() 迭代器當(dāng)前位置，反向遍歷集合，下一個元素

previousIndex() 迭代器當(dāng)前位置，反向遍歷集合，返回下一個元素的下標(biāo)

nextIndex() 迭代器當(dāng)前位置，返回下一個元素的下標(biāo)

（3）使用范圍不同，Iterator可以迭代所有集合；ListIterator 只能用于List及其子類

ListIterator 有 add 方法，可以向 List 中添加對象；Iterator 不能

ListIterator 有 hasPrevious() 和 previous() 方法，可以實(shí)現(xiàn)逆向遍歷；Iterator不可以

ListIterator 有 nextIndex() 和previousIndex() 方法，可定位當(dāng)前索引的位置；Iterator不可以

ListIterator 有 set()方法，可以實(shí)現(xiàn)對 List 的修改；Iterator 僅能遍歷，不能修改。

快速失敗（fail-fast）策略的核心在于一旦發(fā)現(xiàn)數(shù)據(jù)結(jié)構(gòu)在迭代過程中被修改，系統(tǒng)會立即停止迭代并通過拋出ConcurrentModificationException異常來報告錯誤。這樣做的目的是盡早地發(fā)現(xiàn)錯誤，防止錯誤的擴(kuò)散，從而保證軟件的穩(wěn)定性和可靠性。例如，在使用ArrayList或HashMap等集合類進(jìn)行迭代時，如果嘗試在迭代過程中修改集合內(nèi)容，就會觸發(fā)這種快速失敗的行為。

安全失敗（fail-safe）策略則相對寬容，它允許在迭代過程中對數(shù)據(jù)結(jié)構(gòu)進(jìn)行修改，而不會立即拋出異常。這種策略通常通過使用額外的措施，如迭代器復(fù)制、鎖或其他同步機(jī)制，來確保即使在多線程環(huán)境下也能安全地進(jìn)行操作。這樣可以減少因并發(fā)修改導(dǎo)致的問題，提高程序的容錯性。