引言

??了解Set集合如何使用和旗下各類比較，這篇我們繼續和大家一起看看Map集合的使用機制。

Map

Map集合介紹

??Map(也稱為字典、關聯數組)是用于保存具有映射關系的數據，保存兩組值，key和value，這兩組值可以是任何應用類型的數據。
??Map的key不允許重復(底層Map的keySet()返回的是key的Set集合，所以key不會重復)，即Map中對象的任意兩個key通過equals()方法得到的都是false。而，Map的value值是可以重復的(Map的底層values()方法返回類型是Collection，可以存儲重復元素)，通過key總能找到唯一的value，Map中的key組成一個Set集合，所以可以通過keySet()方法返回所有key。Set底層也是通過Map實現的，只不過value都是null的Map來實現的。

public class HashSet<E>extends AbstractSet<E>implements Set<E>, Cloneable, java.io.Serializable{
static final long serialVersionUID = -5024744406713321676L;

private transient HashMap map;// Dummy value to associate with an Object in the backing Mapprivate static final Object PRESENT = new Object();public HashSet() {
map = new HashMap<>();
}public HashSet(Collection extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}public boolean add(E e) {return map.put(e, PRESENT)==null;
}
}

Map實現類

??Map典型的實現類是HashMap、Hashtable(HashMap子類還有LinkedHashMap)、SortedMap子接口及實現類TreeMap、WeakHashMap、IndentityHashMap等。
??Map有一個內部類Entry，該類封裝了key-value對，有如下三個方法：

• K getKey();：獲取Entry中的key值；
• V getValue();：獲取Entry中的value值；
• V setValue(V value);：設置Entry中的value值，并返回新設置的value值。

Map常用方法

• int size();：返回Map的key-value對的長度。
• boolean isEmpty();：判斷該Map是否為空。
• boolean containsKey(Object key);：判斷該Map中是否包含指定的key。
• boolean containsValue(Object value);：判斷該Map是否包含一個或多個value。
• V get(Object key);：獲取某個key所對應的value；若不包含該key，則返回null。
• V put(K key, V value);：向Map添加key-value對，當Map中有一個與該key相等的key-value對，則新的會去覆蓋舊的。
• V remove(Object key);：移除指定的key所對應的key-value對，若成功刪除，則返回移除的value值。
• void putAll(Map extends K, ? extends V> m);：將指定的Map中的key-value對全部復制到該Map中。
• void clear();：清除Map中的所有key-value對。
• Set keySet();：獲取該Map中所有key組成的Set集合。
• Collection values();：獲取該Map中所有value組成的Collection。
• Set> entrySet();：返回該Map中Entry類的Set集合。
• boolean remove(Object key, Object value) ：刪除指定的key-value對，若刪除成功，則返回true；否則，返回false。

HashMap

HashMap介紹

??HashMap底層是數組+鏈表的形式，實現Map.Entry接口，數組是Entry[]數組，是一個靜態內部類，Entry是key-value鍵值對，持有一個指向下一個元素的next引用，這就構成鏈表(單向鏈表)。
??HashMap底層是數組和鏈表的結合體。底層是一個線性數組結構，數組中的每一項又是一個鏈表。當新建一個HashMap的時候，就會初始化一個數組。數組是Entry[]數組，靜態內部類。Entry就是數組中的元素，每個 Map.Entry 其實就是一個key-value對，它持有一個指向下一個元素的引用next，這就構成了鏈表。
??根據指定的hash值找到在table中的索引；HashMap底層數組的長度是2^n，默認是16,負載因子為0.75，所以最大容量閾值threshold = (int)(capacity * loadFactor);即16*0.75=12，當超過這個閾值的時候，開始擴容，即每次擴容增加一倍。

HashMap LoadFactor源碼

static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* Constructs an empty HashMap with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

底層讀寫元素原理

底層讀寫元素原理

by https://www.cnblogs.com/shileibrave/p/9836731.html

put實現原理

??當我們往HashMap中put元素的時候：當程序試圖將一個key-value對放入HashMap中時，

程序首先根據該 key 的hashCode() 返回值再hash，決定該 Entry 的存儲位置。(定位槽位在哪)

若Entry的存儲位置上為null，直接存儲該對象；若不為空，兩個 Entry 的 key 的 hashCode() 返回值相同，那它們的存儲位置相同。(判斷槽位是否可以呆)

循環遍歷鏈表，如果這兩個 Entry 的 key 通過equals() 比較返回 true，新添加 Entry 的 value 將覆蓋集合中原有 Entry 的value，但key不會覆蓋；如果這兩個 Entry 的 key 通過equals()比較返回 false，將該對象放到數組中，然后將數組中原有的Entry對象鏈接到此對象后面。新添加的 Entry 將與集合中原有 Entry 形成Entry鏈，而且新添加的Entry位于 Entry 鏈的頭部。(鏈式添加)

get實現原理

??從HashMap中get元素時，

首先計算key的hash值，通過再hash函數，找到數組中對應位置的某一元素；(定位槽位)

然后通過key的equals()方法(key同不同)在對應位置的鏈表中找到需要的元素。(判斷鏈表位置)

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

遍歷Map的方式

第一種方式：Iterator的方式

Iterator> itr = map.entrySet().iterator();//等價于Set> set = map.entrySet();//Iterator> itr = set.iterator();while(itr.hasNext()){
Map.Entry entry = itr.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+" : "+value);
}

第二種：增強型for循環

//使用增強型for循環
for(Map.Entry entry : map.entrySet()){
System.out.println(entry.getKey() +"=" +entry.getValue());
}

HashMap示例

1)運行主類

public class DemoApplication {

public static void main(String[] args) {

Map bookMap = new HashMap<>();
bookMap.put(1,"book01");
bookMap.put(2,"book02");
bookMap.put(3,"book03");
bookMap.put(4,"book04");
bookMap.put(5,"book01");
System.out.println("原集合：" + bookMap);//獲取map大小
System.out.println("size()獲取map大小：" + bookMap.size());//判斷map是否為空
System.out.println("isEmpty()判斷是否為空：" + bookMap.isEmpty());//判斷該Map中是否包含指定的key
System.out.println("containsKey()判斷該Map中是否包含指定的key：" + bookMap.containsKey(2));//判斷該Map是否包含一個或多個value
System.out.println("containsValue()判斷該Map是否包含一個或多個value：" + bookMap.containsValue("book01"));//獲取某個key所對應的value；若不包含該key，則返回null
System.out.println("獲取某個key所對應的value：" + bookMap.get(2));
System.out.println("獲取某個key所對應的value；若不包含該key，則返回null：" + bookMap.get(100));//put重復key，覆蓋舊value；
System.out.println("put重復key：" + bookMap.put(1,"book001"));
System.out.println("新集合：" + bookMap);//移除指定的key所對應的key-value對，若成功刪除，則返回移除的value值。
System.out.println("移除指定的key所對應的key-value對：" + bookMap.remove(1));//將指定的Map中的key-value對全部復制到該Map中
Map newMap = new HashMap<>();
newMap.put(10, "book10");
newMap.put(11, "book11");
System.out.println("newMap：" + newMap);
bookMap.putAll(newMap);
System.out.println("putAll()將指定的Map中的key-value對全部復制到該Map中：" + bookMap);//清除Map中的所有key-value對
newMap.clear();
System.out.println("clear()清除Map中的所有key-value對：" + newMap);//獲取該Map中所有key組成的Set集合
Set keySet = bookMap.keySet();
System.out.println("keySet()獲取該Map中所有key組成的Set集合：" + keySet);//獲取該Map中所有value組成的Collection
Collection values = bookMap.values();
System.out.println("values()獲取該Map中所有value組成的Collection：" + values);//返回該Map中Entry類的Set集合
Set> entrySet = bookMap.entrySet();
Iterator> iterator = entrySet.iterator();while (iterator.hasNext()) {
Map.Entry entry = iterator.next();
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println("key=" + key + ", value=" + value);
}//刪除指定的key-value對，若刪除成功，則返回true；否則，返回false。
System.out.println("刪除指定的key-value對，若刪除成功(存在)：" + bookMap.remove(2, "book02"));
System.out.println("刪除指定的key-value對，若刪除成功(不存在)：" + bookMap.remove(2, "book02"));
}
}

2)運行結果：

原集合：{1=book01, 2=book02, 3=book03, 4=book04, 5=book01}
size()獲取map大小：5
isEmpty()判斷是否為空：falsecontainsKey()判斷該Map中是否包含指定的key：truecontainsValue()判斷該Map是否包含一個或多個value：true
獲取某個key所對應的value：book02
獲取某個key所對應的value；若不包含該key，則返回null：null
put重復key：book01
新集合：{1=book001, 2=book02, 3=book03, 4=book04, 5=book01}
移除指定的key所對應的key-value對：book001
newMap：{10=book10, 11=book11}
putAll()將指定的Map中的key-value對全部復制到該Map中：{2=book02, 3=book03, 4=book04, 5=book01, 10=book10, 11=book11}
clear()清除Map中的所有key-value對：{}
keySet()獲取該Map中所有key組成的Set集合：[2, 3, 4, 5, 10, 11]
values()獲取該Map中所有value組成的Collection：[book02, book03, book04, book01, book10, book11]
key=2, value=book02
key=3, value=book03
key=4, value=book04
key=5, value=book01
key=10, value=book10
key=11, value=book11
刪除指定的key-value對，若刪除成功(存在)：true
刪除指定的key-value對，若刪除成功(不存在)：false

Hashtable介紹

??Hashtable是和HashMap一樣，屬于Map典型的實現類，區別于HashMap的是，Hashtable是線程安全的Map實現，但是性能低。Hashtable不允許使用null作為key和value；若將null值存入Hashtable，會拋出NullPointerException異常；而HashMap可以使用null作為key或value。

LinkedHashMap介紹

??LinkedHashMap是HashMap的子類，使用雙向鏈表維護key-value對的順序(只是關注key的順序)，迭代順序和key-value插入Map中的順序保持一致。

Properties介紹

??Properties類是Hashtable類的子類。通常作為處理屬性配置文件比較好。可以將Map對象中的key-value配置寫入到屬性文件中，反之，也可以將屬性文件中的key=value加載到Map對象中。注意，屬性文件中的屬性key-value只能是字符串類型。提供以下幾個方法來操作Properties

• synchronized Object setProperty(String key, String value)：設置屬性值，底層是通過put來實現。

public synchronized Object setProperty(String key, String value) {
return put(key, value);
}

• String getProperty(String key)：獲取指定屬性名的屬性值，底層是通過Map的get(Object key)來實現。

public String getProperty(String key) {
Object oval = super.get(key);
String sval = (oval instanceof String) ? (String)oval : null;
return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
}

• String getProperty(String key, String defaultValue)：類似于getProperty(String key)方法，在此基礎上多一個功能是當Properties中不存在指定的key時，該方法指定默認值去獲取。
• synchronized void load(InputStream inStream) throws IOException ：從屬性文件以輸入流的方式加載key-value對，并將這些key-value追加到Properties中。
• void store(OutputStream out, String comments)：將Properties中的key-value對以輸出流的方式輸出到指定的屬性文件中。

TreeMap介紹

??TreeMap是SortedMap接口的實現類，TreeMap底層是紅黑樹數據結構，每個key-value作為紅黑樹的一個節點。TreeMap存儲節點時，根據key對節點進行排序，主要是自然排序和自定義排序。類似于TreeSet。

WeakHashMap介紹

??WeakHashMap用法基本和HashMap類似，不同的是WeakHashMap是對實際對象的弱引用，弱引用就是當WeakHashMap的key所引用的對象沒有被其他強引用變量進行引用時，key所對應的對象就可能會被垃圾回收，WeakHashMap會自動刪除該key所對應的key-value對。而HashMap的key是保留實際對象的強引用，強引用就是當HashMap對象不被銷毀的時候，HashMap所有key所引用的對象就不會被垃圾回收。

IdentityHashMap介紹

??IdentityHashMap也基本類似于HashMap，有一些特殊的地方在于：判斷兩個key相等。HashMap中判斷key相等只需要判斷兩個key通過equals()方法比較返回true，而IdentityHashMap是僅當兩個key通過(key1==key2)相等時才認為相等。IdentityHashMap同樣支持null作為key和value。

EnumMap介紹

??EnumMap是Map的枚舉實現類，所有key都必須是單個枚舉類的枚舉值。創建EnumMap的時候必須顯式或者隱式指定對應的枚舉類。??EnumMap在內部是以數組的形式保存元素，根據key的自然順序，即枚舉值在枚舉類中定義的順序來保存key-value對的順序。EnumMap不允許null作為key，但是可以使用null作為value。

Q&A

HashMap的擴容resize原理，如何擴容？

??當HashMap內的元素對象存儲的爆滿時，就容易出現hash沖突的現象，這個時候就需要底層數組擴容。當然，HashMap這種擴容的操作也是比較消耗性能的，因為這需要原數組中的數據重新計算其在新數組中的位置。下面我們看看底層是如何擴容的
??擴容的時機是什么？當HashMap中的元素個數超過數組大小時(即負載因子loadFactor)，HashMap底層就會進行數組的擴容。loadFactor的默認值為0.75，這是一個折中的取值。
??如何擴？數組大小默認為16，當HashMap中元素對象個數超過16*0.75=12時，就把數組的大小擴容到2*16=32，即擴大一倍，然后重新計算每個元素在數組中的位置，而這是一個非常消耗性能的操作，因此實際使用的時候，如果我們開發人員根據業務需求，大概了解HashMap需要存儲多少元素時，我們可以估計一下元素的個數去限定HashMap的大小，這樣就可以提高HashMap的性能。

• 折中操作：負載因子loadFactor衡量的是一個散列表的空間的使用程度，負載因子越大表示散列表空間利用率高。查找一個元素的平均時間為o(1+a)，當負載因子變大的時候，空間利用率高了，但是查詢效率降低；當負載因子變小的時候，元素就會稀疏，但是查詢效率高，所以要折中時間和空間。

解決hash沖突的方法有哪些？

開放定址法：線性探測再散列、二次探測再散列、隨機探測再散列；

再哈希法：換一種哈希函數；

鏈地址法：在數組中沖突元素后面拉一條鏈路，存儲重復的元素；

建立一個公共溢出區：其實就是建立一個表，存放那些沖突的元素。

HashMap中什么時候會產生沖突？

??HashMap中調用hashCode()方法來計算hashCode。由于在Java中兩個不同的對象可能有一樣的hashCode,所以不同的鍵可能有一樣hashCode，從而導致沖突的產生。

Java8中HashMap和LinkedHashMap如何解決沖突？

在Java8之前，HashMap和其他基于map的類都是通過鏈地址法解決沖突，它們使用單向鏈表來存儲相同索引值的元素。在最壞的情況下，這種方式會將HashMap的get方法的性能從O(1)降低到O(n)。為了解決在頻繁沖突時Hashmap性能降低的問題，Java 8中使用平衡樹來替代鏈表存儲沖突的元素。這意味著我們可以將最壞情況下的性能從O(n)提高到O(logn)。

在Java 8中使用常量TREEIFY_THRESHOLD來控制是否切換到平衡樹來存儲。目前，這個常量值是8，這意味著當有超過8個元素的索引一樣時，HashMap會使用樹來存儲它們。

在Java 7中為了優化常用類對ArrayList和HashMap采用了延遲加載的機制，在有元素加入之前不會分配內存，這會減少空的鏈表和HashMap占用的內存。

這種動態解決hash沖突的特性使得HashMap一開始使用鏈表，并在沖突的元素數量超過指定值時用平衡二叉樹替換鏈表。這一特性在所有基于hash table的類中沒有，例如Hashtable和WeakHashMap。只有ConcurrentHashMap,LinkedHashMap和HashMap會在頻繁沖突的情況下使用平衡樹。

??以上就是Java中HashMap如何處理沖突。這種方法被稱為鏈地址法，因為使用鏈表存儲同一桶內的元素。通常情況HashMap，HashSet，LinkedHashSet，LinkedHashMap，ConcurrentHashMap，HashTable，IdentityHashMap和WeakHashMap均采用這種方法處理沖突。從JDK 8開始，HashMap，LinkedHashMap和ConcurrentHashMap為了提升性能，在頻繁沖突的時候使用平衡樹來替代鏈表。因為HashSet內部使用了HashMap，LinkedHashSet內部使用了LinkedHashMap，所以他們的性能也會得到提升。

HashMap和TreeMap區別

查詢插入等用途：在Map中插入、刪除和定位元素，HashMap適合；若要按順序遍歷鍵，則TreeMap適合。

優化：HashMap可以調優初始容量和負載因子；TreeMap沒有調優選項，因為樹總處于平衡狀態。

實現接口：都實現了Cloneable接口。TreeMap實現SortMap接口，能夠把它保存的記錄根據鍵排序(默認按鍵的升序)，HashMap繼承AbstractMap；

底層實現：TreeMap底層是數組+紅黑樹；HashMap底層是數組+鏈表法(從Java 8開始，HashMap，ConcurrentHashMap和LinkedHashMap在處理頻繁沖突時將使用平衡樹來代替鏈表，當同一hash桶中的元素數量超過特定的值(默認為8)便會由鏈表切換到平衡樹，這會將get()方法的性能從O(n)提高到O(logn)。)

Hashmap和Hashset區別

?&esmp;HashSet底層是通過HashMap實現的。add的時候，調用map的put方法，value始終是PRESENT，所以HashSet是所有value值都相同的HashMap。

實現接口：HashSet實現了Set集合的接口，不允許有重復的值(準確說應該是元素作為key，value是定義為final的對象)，將對象存儲在HashSet之前，需要確保對象已經重寫了equals和hashCode方法，這樣才能比較兩個對象的值是否相等，確保set中沒有存儲相等的對象。HashMap實現了Map集合接口，對鍵值對進行映射。Map中不允許重復的鍵。

存儲元素：HashMap存儲的是鍵值對，不允許有重復的鍵；Hashset存儲的是對象，不能有重復的對象元素。

添加元素方法：HashMap使用put方法將元素放入map中，HashSet使用add方法將元素放入set中。

hashCode值的計算：HashMap中使用鍵對象計算hashcode的值，HashSet中使用成員對象來計算hashcode值。

效率：HashMap比較快，因為使用唯一的鍵來獲取對象，HashSet比HashMap慢。

底層實現：HashSet是所有value值都相同的HashMap。HashSet內部使用HashMap實現，只不過HashSet里面的HashMap所有的value都是同一個object而已。private transient HashMap map;只是包含了hashmap的key。

HashMap和Hashtable異同

同：
??兩者都是用key-value方式獲取數據。異：

null值：HashMap允許null值作為key和value；Hashtable不允許null的鍵值；

順序性：HashMap不保證映射的順序不變，但是作為HashMap的子類LinkedHashMap默認按照插入順序來進行映射的順序；Hashtable無法保證；

線程安全：HashMap是非同步的(非線程安全)，效率高；Hashtable是同步的(線程安全的)，效率低。(HashMap同步通過Collections.synchronizedMap()實現)

快速失敗機制：迭代HashMap采用fail-fast快速失敗機制(快速失敗機制：是一個線程或軟件對于其故障做出的響應，用來即時報告可能會導致失敗的任何故障情況，如果一個Iterator在集合對象上創建了，其他線程想結構化的修改該集合對象，拋出并發修改異常ConcurrentModificationException)；而HashTable的enumerator迭代器不是fail-fast的(Hashtable的上下文同步：一個時間點只能有一個線程可以修改哈希表，任何線程在執行Hashtable的更新操作前需要獲取對象鎖，其他線程等待鎖的釋放；

父類：HashMap繼承AbstractMap，Hashtable繼承Dictionary；

數組默認大小：HashMap底層數組的默認大小是16，擴容是2*old；Hashtable底層數組默認是11，擴容方式是2*old+1；

效率：HashMap是非線程安全的，單線程下效率高；Hashtable是線程安全的，方法都加了synchronized關鍵字進行同步，效率較低；

計算hash方式不同：HashMap是二次hash，對key的hashCode進行二次hash，獲得更好的散列值；而Hashtable是直接使用key的hashCode對table數組進行取模。

如何讓HashMap同步

??通過Collections集合工具類中的synchronizedMap()方法實現同步：Map map = Collections.synchronizedMap(hashMap);。Collections.synchronizedMap()實現原理是Collections定義了一個SynchronizedMap的內部類，這個類實現了Map接口，在調用方法時使用synchronized來保證線程同步,當然了實際上操作的還是我們傳入的。

源碼

private static class SynchronizedMap<K,V>implements Map<K,V>, Serializable {
private static final long serialVersionUID = 1978198479659022715L;

private final Map m; // Backing Mapfinal Object mutex; // Object on which to synchronize
SynchronizedMap(Map m) {this.m = Objects.requireNonNull(m);
mutex = this;
}
SynchronizedMap(Map m, Object mutex) {this.m = m;this.mutex = mutex;
}public int size() {synchronized (mutex) {return m.size();}
}public boolean isEmpty() {synchronized (mutex) {return m.isEmpty();}
}public boolean containsKey(Object key) {synchronized (mutex) {return m.containsKey(key);}
}public boolean containsValue(Object value) {synchronized (mutex) {return m.containsValue(value);}
}public V get(Object key) {synchronized (mutex) {return m.get(key);}
}public V put(K key, V value) {synchronized (mutex) {return m.put(key, value);}
}public V remove(Object key) {synchronized (mutex) {return m.remove(key);}
}public void putAll(Map extends K, ? extends V> map) {synchronized (mutex) {m.putAll(map);}
}public void clear() {synchronized (mutex) {m.clear();}
}private transient Set keySet;private transient Set> entrySet;private transient Collection values;public SetkeySet() {synchronized (mutex) {if (keySet==null)
keySet = new SynchronizedSet<>(m.keySet(), mutex);return keySet;
}
}public Set> entrySet() {synchronized (mutex) {if (entrySet==null)
entrySet = new SynchronizedSet<>(m.entrySet(), mutex);return entrySet;
}
}public Collectionvalues() {synchronized (mutex) {if (values==null)
values = new SynchronizedCollection<>(m.values(), mutex);return values;
}
}public boolean equals(Object o) {if (this == o)return true;synchronized (mutex) {return m.equals(o);}
}public int hashCode() {synchronized (mutex) {return m.hashCode();}
}public String toString() {synchronized (mutex) {return m.toString();}
}// Override default methods in Map@Overridepublic V getOrDefault(Object k, V defaultValue) {synchronized (mutex) {return m.getOrDefault(k, defaultValue);}
}@Overridepublic void forEach(BiConsumer super K, ? super V> action) {synchronized (mutex) {m.forEach(action);}
}@Overridepublic void replaceAll(BiFunction super K, ? super V, ? extends V> function) {synchronized (mutex) {m.replaceAll(function);}
}@Overridepublic V putIfAbsent(K key, V value) {synchronized (mutex) {return m.putIfAbsent(key, value);}
}@Overridepublic boolean remove(Object key, Object value) {synchronized (mutex) {return m.remove(key, value);}
}@Overridepublic boolean replace(K key, V oldValue, V newValue) {synchronized (mutex) {return m.replace(key, oldValue, newValue);}
}@Overridepublic V replace(K key, V value) {synchronized (mutex) {return m.replace(key, value);}
}@Overridepublic V computeIfAbsent(K key,
Function super K, ? extends V> mappingFunction) {synchronized (mutex) {return m.computeIfAbsent(key, mappingFunction);}
}@Overridepublic V computeIfPresent(K key,
BiFunction super K, ? super V, ? extends V> remappingFunction) {synchronized (mutex) {return m.computeIfPresent(key, remappingFunction);}
}@Overridepublic V compute(K key,
BiFunction super K, ? super V, ? extends V> remappingFunction) {synchronized (mutex) {return m.compute(key, remappingFunction);}
}@Overridepublic V merge(K key, V value,
BiFunction super V, ? super V, ? extends V> remappingFunction) {synchronized (mutex) {return m.merge(key, value, remappingFunction);}
}private void writeObject(ObjectOutputStream s) throws IOException {synchronized (mutex) {s.defaultWriteObject();}
}
}

[每篇微語]

做人有三碗面最難吃：人面、場面、情面。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?? ?——?杜月笙

總結

以上是生活随笔為你收集整理的c++ map iterator 获取key_JAVA | Map集合使用详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。