集合-HashMap

集合-Map接口及其多個實現類的對比

* 一、Map的 實現類 的結構：* |----Map:雙列數據，存儲key-value對的數據 ---類似于高中的函數：y = f(x)* |----HashMap:作為Map的主要實現類；線程不安全的，效率高；可以存儲null 的 key和value* |----LinkedHashMap:保證在遍歷map元素時，可以按照添加的順序實現遍歷。（鏈式遍歷）* 原因：在原有的HashMap底層結構基礎上，添加了一對指針，指向前一個和后一個元素，方便找前一個和后一個。* 對于頻繁的遍歷操作，此類執行效率高于HashMap。* 頻繁的去遍歷考慮使用LinkedHashMap，除此之外沒有特殊需求就HashMap就行。* |----TreeMap:保證可以按照添加的key-value對進行排序，實現排序遍歷。此時考慮key的自然排序或定制排序* 底層使用紅黑樹* |----Hashtable:作為古老的實現類（在jdk1.0就有了）；線程安全的，效率低；不能存儲null 的 key和value* Properties作為Hashtable的子類* |----Properties:常用來處理配置文件。特點：key和value都是String類型*** HashMap的底層：數組+鏈表 （jdk7及之前）* 數組+鏈表+紅黑樹 （jdk 8）*** 面試題：* 1. HashMap的底層實現原理？* 2. HashMap 和 Hashtable的異同？ 見上面* 3. CurrentHashMap 與 Hashtable的異同？（暫時不講）

集合-Map中存儲的key-value的特點

key不能重復，value是可以重復的。
所有的key用Set存，value用Collection存。
Map其實放的還是一個數據，這個數據叫Entry，只不過這個數據有兩個屬性，一個屬性叫key，一個叫value。
每次放進倆屬性，其實先包裝成Entry。

二、Map結構的理解：* Map中的key:無序的、不可重復的，使用Set存儲所有的key。HashMap用hashset存，LinkedHashMap用linkset存。* ↑---> 因為是不可重復的，所以要判斷equals（），所以如果使用自定義的類，key所在的類要重寫equals()和hashCode() （以HashMap為例）* Map中的value:無序的、可重復的，使用Collection存儲所有的value --->因為有個方法要判斷集合中是否有一樣的，要判斷equals（），所以value所在的類要重寫equals()* 一個鍵值對：key-value構成了一個Entry對象。* Map中的entry:無序的、不可重復的，使用Set存儲所有的entry

HashMap的在JDK7中的底層實現原理

三、HashMap的底層實現原理？以jdk7為例說明：* HashMap map = new HashMap():* 在實例化以后，底層創建了長度是16的一維數組Entry[] table。此數組類型是Entry。* ...可能已經執行過多次put...* map.put(key1,value1):* 首先，調用key1所在類的hashCode()計算key1哈希值，此哈希值經過某種算法計算以后，得到在Entry數組中的存放位置。* 如果此位置上的數據為空，此時的key1-value1添加成功。 ----情況1* 如果此位置上的數據不為空，(意味著此位置上存在一個或多個數據(以鏈表形式存在)),比較key1和已經存在的一個或多個數據* 的哈希值：* 如果key1的哈希值與已經存在的數據的哈希值都不相同，此時key1-value1添加成功。----情況2* 如果key1的哈希值和已經存在的某一個數據(key2-value2)的哈希值相同，繼續比較：調用key1所在類的equals(key2)方法，比較：* 如果equals()返回false:此時key1-value1添加成功。----情況3* 如果equals()返回true:使用value1替換value2。比如原來存的是（tom，30），后來添加（tom，45）之后，就把（tom，30）替換了，只能查到（tom，45）了。** 補充：關于情況2和情況3：此時key1-value1和原來的數據以鏈表的方式存儲。** 在不斷的添加過程中，會涉及到擴容問題，當超出臨界值(且要存放的位置非空)時，擴容。默認的擴容方式：擴容為原來容量的2倍，并將原有的數據復制過來。

HashMap的在JDK8中的底層實現原理

jdk8 相較于jdk7在底層實現方面的不同：* 1. new HashMap():底層沒有創建一個長度為16的數組* 2. jdk 8底層的數組是：Node[],而非Entry[]* 3. 首次調用put()方法時，底層創建長度為16的數組* 4. jdk7底層結構只有：數組+鏈表。jdk8中底層結構：數組+鏈表+紅黑樹。* 4.1 形成鏈表時，七上八下（jdk7:新的元素指向舊的元素。jdk8：舊的元素指向新的元素）4.2 當數組的某一個索引位置上的元素以鏈表形式存在的數據個數 > 8 且 當前數組的長度 > 64時，此時此索引位置上的所有數據改為使用紅黑樹存儲（為了遍歷快，查找方便，提高效率）。

集合-HashMap在JDK7中的源碼分析

集合-HashMap在JDK8中的源碼分析

數組上鏈表和紅黑樹共存，能同時存在，都有，而不是有紅黑樹后就全改成紅黑樹。

* DEFAULT_INITIAL_CAPACITY : HashMap的默認容量，16* DEFAULT_LOAD_FACTOR：HashMap的默認加載因子：0.75* threshold：擴容的臨界值，=容量*填充因子：16 * 0.75 => 12 ，臨界值，不到16才擴，到12就可以擴容了。* TREEIFY_THRESHOLD：Bucket中鏈表長度大于該默認值，轉化為紅黑樹:8* MIN_TREEIFY_CAPACITY：桶中的Node被樹化時最小的hash表容量:64** 為什么填充因子0.75？* 答：hash隨機插入到數組元素，并不是一個個的按順序占用的數組，* 提前去擴是為了讓出現鏈表少一些，如果加載因子盡可能的小一些，比如0.3，16×0.3約等于4，超過4個就要擴容，數組的利用率很低，* 如果太大，0.9，可能鏈表又有點多了，需要找個相對穩定的值。既不浪費數組空間，降低數組利用率，又使得鏈表少一些，經過統計學規律大量測試，可選擇0.75這個數據達到最佳平衡。

集合-LinkedHashMap的底層實現

* 四、LinkedHashMap的底層實現原理（了解）* 源碼中：* static class Entry<K,V> extends HashMap.Node<K,V> {Entry<K,V> before, after;//這是比HashMap多出來的一行，能夠記錄添加的元素的先后順序Entry(int hash, K key, V value, Node<K,V> next) {super(hash, key, value, next);}}

集合-Map中的常用方法

---

map.clear（）底層是把size設置為0，數組元素全設置成null。
isEmpty（）是判斷size是否為0，為0就返回True。

---

常用方法的代碼以及 小的總結

package com.atguigu.java;import org.junit.Test;import java.util.*;/*** 一、Map的 實現類 的結構：* |----Map:雙列數據，存儲key-value對的數據 ---類似于高中的函數：y = f(x)* |----HashMap:作為Map的主要實現類；線程不安全的，效率高；可以存儲null 的 key和value* |----LinkedHashMap:保證在遍歷map元素時，可以按照添加的順序實現遍歷。（鏈式遍歷）* 原因：在原有的HashMap底層結構基礎上，添加了一對指針，指向前一個和后一個元素，方便找前一個和后一個。* 對于頻繁的遍歷操作，此類執行效率高于HashMap。* 頻繁的去遍歷考慮使用LinkedHashMap，除此之外沒有特殊需求就HashMap就行。* |----TreeMap:保證可以按照添加的key-value對進行排序，實現排序遍歷。此時考慮key的自然排序或定制排序* 底層使用紅黑樹* |----Hashtable:作為古老的實現類（在jdk1.0就有了）；線程安全的，效率低；不能存儲null 的 key和value* Properties作為Hashtable的子類* |----Properties:常用來處理配置文件。特點：key和value都是String類型*** HashMap的底層：數組+鏈表 （jdk7及之前）* 數組+鏈表+紅黑樹 （jdk 8）*** 面試題：* 1. HashMap的底層實現原理？* 2. HashMap 和 Hashtable的異同？ 見上面* 3. CurrentHashMap 與 Hashtable的異同？（暫時不講）** 二、Map結構的理解：* Map中的key:無序的、不可重復的，使用Set存儲所有的key。HashMap用hashset存，LinkedHashMap用linkset存。* ↑---> 因為是不可重復的，所以要判斷equals（），所以如果使用自定義的類，key所在的類要重寫equals()和hashCode() （以HashMap為例）* Map中的value:無序的、可重復的，使用Collection存儲所有的value --->因為有個方法要判斷集合中是否有一樣的，要判斷equals（），所以value所在的類要重寫equals()* 一個鍵值對：key-value構成了一個Entry對象。* Map中的entry:無序的、不可重復的，使用Set存儲所有的entry** 三、HashMap的底層實現原理？以jdk7為例說明：* HashMap map = new HashMap():* 在實例化以后，底層創建了長度是16的一維數組Entry[] table。此數組類型是Entry。* ...可能已經執行過多次put...* map.put(key1,value1):* 首先，調用key1所在類的hashCode()計算key1哈希值，此哈希值經過某種算法計算以后，得到在Entry數組中的存放位置。* 如果此位置上的數據為空，此時的key1-value1添加成功。 ----情況1* 如果此位置上的數據不為空，(意味著此位置上存在一個或多個數據(以鏈表形式存在)),比較key1和已經存在的一個或多個數據* 的哈希值：* 如果key1的哈希值與已經存在的數據的哈希值都不相同，此時key1-value1添加成功。----情況2* 如果key1的哈希值和已經存在的某一個數據(key2-value2)的哈希值相同，繼續比較：調用key1所在類的equals(key2)方法，比較：* 如果equals()返回false:此時key1-value1添加成功。----情況3* 如果equals()返回true:使用value1替換value2。比如原來存的是（tom，30），后來添加（tom，45）之后，就把（tom，30）替換了，只能查到（tom，45）了。** 補充：關于情況2和情況3：此時key1-value1和原來的數據以鏈表的方式存儲。** 在不斷的添加過程中，會涉及到擴容問題，當超出臨界值(且要存放的位置非空)時，擴容。默認的擴容方式：擴容為原來容量的2倍，并將原有的數據復制過來。** jdk8 相較于jdk7在底層實現方面的不同：* 1. new HashMap():底層沒有創建一個長度為16的數組* 2. jdk 8底層的數組是：Node[],而非Entry[]* 3. 首次調用put()方法時，底層創建長度為16的數組* 4. jdk7底層結構只有：數組+鏈表。jdk8中底層結構：數組+鏈表+紅黑樹。* 4.1 形成鏈表時，七上八下（jdk7:新的元素指向舊的元素。jdk8：舊的元素指向新的元素）4.2 當數組的某一個索引位置上的元素以鏈表形式存在的數據個數 > 8 且 當前數組的長度 > 64時，此時此索引位置上的所有數據改為使用紅黑樹存儲（為了遍歷快，查找方便，提高效率）。** DEFAULT_INITIAL_CAPACITY : HashMap的默認容量，16* DEFAULT_LOAD_FACTOR：HashMap的默認加載因子：0.75* threshold：擴容的臨界值，=容量*填充因子：16 * 0.75 => 12 ，臨界值，不到16才擴，到12就可以擴容了。* TREEIFY_THRESHOLD：Bucket中鏈表長度大于該默認值，轉化為紅黑樹:8* MIN_TREEIFY_CAPACITY：桶中的Node被樹化時最小的hash表容量:64** 為什么填充因子0.75？* 答：hash隨機插入到數組元素，并不是一個個的按順序占用的數組，* 提前去擴是為了讓出現鏈表少一些，如果加載因子盡可能的小一些，比如0.3，16×0.3約等于4，超過4個就要擴容，數組的利用率很低，* 如果太大，0.9，可能鏈表又有點多了，需要找個相對穩定的值。既不浪費數組空間，降低數組利用率，又使得鏈表少一些，經過統計學規律大量測試，可選擇0.75這個數據達到最佳平衡。** 四、LinkedHashMap的底層實現原理（了解）* 源碼中：* static class Entry<K,V> extends HashMap.Node<K,V> {Entry<K,V> before, after;//這是比HashMap多出來的一行，能夠記錄添加的元素的先后順序Entry(int hash, K key, V value, Node<K,V> next) {super(hash, key, value, next);}}*** 五、Map中定義的方法：添加、刪除、修改操作：Object put(Object key,Object value)：將指定key-value添加到(或修改)當前map對象中void putAll(Map m):將m中的所有key-value對存放到當前map中Object remove(Object key)：移除指定key的key-value對，并返回valuevoid clear()：清空當前map中的所有數據元素查詢的操作：Object get(Object key)：獲取指定key對應的valueboolean containsKey(Object key)：是否包含指定的keyboolean containsValue(Object value)：是否包含指定的valueint size()：返回map中key-value對的個數boolean isEmpty()：判斷當前map是否為空boolean equals(Object obj)：判斷當前map和參數對象obj是否相等(兩個map一樣就返回True)元視圖操作的方法：Set keySet()：返回所有key構成的Set集合Collection values()：返回所有value構成的Collection集合Set entrySet()：返回所有key-value對構成的Set集合*總結：常用方法：* 添加：put(Object key,Object value)* 刪除：remove(Object key)* 修改：put(Object key,Object value)* 查詢：get(Object key)* 長度：size()* 遍歷：keySet() / values() / entrySet()***/ public class MapTest {/*元視圖操作的方法：Set keySet()：返回所有key構成的Set集合Collection values()：返回所有value構成的Collection集合Set entrySet()：返回所有key-value對構成的Set集合*///迭代器是對于Collection來講的，對于Map無法使用迭代器。要使用下面的迭代方式，使用元視圖再加一些操作實現迭代，詳見方式一，方式二。// Collection和Map不是父子類關系。@Testpublic void test5(){Map map = new HashMap();map.put("AA",123);map.put(45,1234);map.put("BB",56);//遍歷所有的key集：keySet()Set set = map.keySet();Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());//AA//BB//45}System.out.println();//遍歷所有的value集：values()Collection values = map.values();for(Object obj : values){System.out.println(obj);//123//56//1234 values和key的輸出順序是一樣的，123對應key的 AA，56對應key的BB,1234對應key的45}System.out.println();//遍歷所有的key-value//方式一：entrySet()Set entrySet = map.entrySet();此時返回到entrySet集合中的元素都是Map.Entry類型的Iterator iterator1 = entrySet.iterator();while (iterator1.hasNext()){Object obj = iterator1.next();//entrySet集合中的元素都是Map.Entry類型的Map.Entry entry = (Map.Entry) obj;//entry.getKey()獲取entry中的key值，entry.getValue()獲取entry中的value值System.out.println(entry.getKey() + "---->" + entry.getValue());//AA---->123//BB---->56//45---->1234}System.out.println();//方式二(用key和value拼出來一個遍歷entry的方法)：Set keySet = map.keySet();//key構成的SetIterator iterator2 = keySet.iterator();while(iterator2.hasNext()){Object key = iterator2.next();Object value = map.get(key);//獲取對應key的value。System.out.println(key + "=====" + value);//AA=====123//BB=====56//45=====1234}//當然，直接sout （map），也能直接看見元素是啥，只不過這里我們想要把它取出來。}/*元素查詢的操作：Object get(Object key)：獲取指定key對應的valueboolean containsKey(Object key)：是否包含指定的keyboolean containsValue(Object value)：是否包含指定的valueint size()：返回map中key-value對的個數boolean isEmpty()：判斷當前map是否為空boolean equals(Object obj)：判斷當前map和參數對象obj是否相等*/@Testpublic void test4(){Map map = new HashMap();map.put("AA",123);map.put(45,123);map.put("BB",56);// Object get(Object key)System.out.println(map.get(45));//123 ,獲取指定key對應的value,如果key不存在，返回null。//containsKey(Object key),是否包含指定的keyboolean isExist = map.containsKey("BB");System.out.println(isExist);//trueisExist = map.containsValue(123);//是否包含指定的valueSystem.out.println(isExist);//truemap.clear();System.out.println(map.isEmpty());//true ,判斷當前map是否為空}/*添加、刪除、修改操作：Object put(Object key,Object value)：將指定key-value添加到(或修改)當前map對象中void putAll(Map m):將m中的所有key-value對存放到當前map中Object remove(Object key)：移除指定key的key-value對，并返回valuevoid clear()：清空當前map中的所有數據*/@Testpublic void test3(){Map map = new HashMap();//添加map.put("AA",123);//基本數據類型將以包裝類的形式呈現，自動轉化成包裝類map.put(45,123);map.put("BB",56);//修改map.put("AA",87);//把key= "AA"的修改其value為87System.out.println(map);//{AA=87, BB=56, 45=123}Map map1 = new HashMap();map1.put("CC",123);map1.put("DD",123);map.putAll(map1);//將m中的所有key-value對存放到當前map中System.out.println(map);//{AA=87, BB=56, CC=123, DD=123, 45=123}//remove(Object key)Object value = map.remove("CC");//將移除鍵值對的value返回。//Object value = map.remove("CCC");//ccc不存在在map中，返回null。System.out.println(value);//123System.out.println(map);//{AA=87, BB=56, DD=123, 45=123}//clear()map.clear();//與map = null操作不同，map還在，只是里面沒東西了。System.out.println(map.size());//0System.out.println(map);//{}}@Testpublic void test2(){Map map = new HashMap();//HashMap輸出時不是按添加的順序輸出的。{345=BB, 123=AA, 12=CC}map = new LinkedHashMap();map.put(123,"AA");map.put(345,"BB");map.put(12,"CC");System.out.println(map);//{123=AA, 345=BB, 12=CC}//LinkedHashMap能記錄誰先加的誰后加的，能按添加的順序來遍歷，來輸出。}@Testpublic void test1(){Map map = new HashMap();//可以存儲null 的 key和value//map = new Hashtable();//不可以存儲null 的 key和value，有一個是null都不行map.put(null,null);} }

集合-TreeMap

集合-TreeMap兩種添加方式的使用

User類

package com.atguigu.java;/*** User類服務于TreeMapTest測試*/ public class User implements Comparable{private String name;private int age;public User() {}public User(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {System.out.println("User equals()....");if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;User user = (User) o;if (age != user.age) return false;return name != null ? name.equals(user.name) : user.name == null;}@Overridepublic int hashCode() { //return name.hashCode() + age;int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}//按照姓名從大到小排列,年齡從小到大排列@Overridepublic int compareTo(Object o) {if(o instanceof User){User user = (User)o; // return -this.name.compareTo(user.name);int compare = -this.name.compareTo(user.name);if(compare != 0){return compare;}else{return Integer.compare(this.age,user.age);}}else{throw new RuntimeException("輸入的類型不匹配");}} }

TreeMapTest.java

package com.atguigu.java;import org.junit.Test;import java.util.*;/*** TreeMap* ★向TreeMap中添加key-value，要求key必須是由 同一個類 創建的對象*/ public class TreeMapTest {//向TreeMap中添加key-value，要求key必須是由同一個類創建的對象//這道題不能 根據age 也就是value排序，因為都是按照key排序的。//因為要按照key進行排序：自然排序 、定制排序//自然排序@Testpublic void test1(){TreeMap map = new TreeMap();//TreeMap（）空參構造器會自定調用自然排序的邏輯User u1 = new User("Tom",23);User u2 = new User("Jerry",32);User u3 = new User("Jack",20);User u4 = new User("Rose",18);map.put(u1,98);map.put(u2,89);map.put(u3,76);map.put(u4,100);Set entrySet = map.entrySet();Iterator iterator1 = entrySet.iterator();while (iterator1.hasNext()){Object obj = iterator1.next();Map.Entry entry = (Map.Entry) obj;System.out.println(entry.getKey() + "---->" + entry.getValue());//按照姓名從大到小排列,年齡從小到大排列// User{name='Tom', age=23}---->98//User{name='Rose', age=18}---->100//User{name='Jerry', age=32}---->89//User{name='Jack', age=20}---->76}}//定制排序@Testpublic void test2(){TreeMap map = new TreeMap(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if(o1 instanceof User && o2 instanceof User){User u1 = (User)o1;User u2 = (User)o2;//按照年齡排序return Integer.compare(u1.getAge(),u2.getAge());}throw new RuntimeException("輸入的類型不匹配！");}});User u1 = new User("Tom",23);User u2 = new User("Jerry",32);User u3 = new User("Jack",20);User u4 = new User("Rose",18);map.put(u1,98);map.put(u2,89);map.put(u3,76);map.put(u4,100);Set entrySet = map.entrySet();Iterator iterator1 = entrySet.iterator();while (iterator1.hasNext()){Object obj = iterator1.next();Map.Entry entry = (Map.Entry) obj;System.out.println(entry.getKey() + "---->" + entry.getValue());//這道題不能 根據age 也就是value排序，因為都是按照key排序的。//User{name='Rose', age=18}---->100//User{name='Jack', age=20}---->76//User{name='Tom', age=23}---->98//User{name='Jerry', age=32}---->89}}}

一些自然排序和定制排序的底層源碼的理解。

TreeMap map = new TreeMap();空參就會底層comparator = null;在調用map.put（參數對象）函數時，判斷comparator等于null，就執行 參數對象 的public int compareTo(Object o) ；方法去排序；即自然排序，故我們要重寫put加入的對象的compareTo(Object o)方法。

TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {}；
}；有參數時，底層this.comparator =傳進來的參數 comparator；此時this.comparator不為null；就會調用傳進來的參數的compare(Object o1, Object o2) 方法去排序；即定制排序，故我們在傳入new TreeMap()參數時要重寫compare(Object o1, Object o2) {}方法。

集合-Properties 作為Hashtable的子類

集合-Properties 處理屬性文件

以下是讀取名為 jdbc.properties的配置文件 的操作。
jdbc.properties

name=zql password=14521

PropertiesTest.java

package com.atguigu.java;import java.io.FileInputStream; import java.io.IOException; import java.util.Properties;/*** Properties*/ public class PropertiesTest {//在idea中，配置文件寫在哪？默認識別在當前工程下，// 在工程下，點右鍵new一個file或者Resource Bundle，// 比如點擊Resource Bundle，輸入名字jdbc，就能生成jdbc.properties文件。//Properties:常用來處理配置文件。key和value都是String類型public static void main(String[] args) {FileInputStream fis = null;try {Properties pros = new Properties();fis = new FileInputStream("jdbc.properties");pros.load(fis);//加載流對應的文件//通過pros讀取文件中的數據String name = pros.getProperty("name");String password = pros.getProperty("password");System.out.println("name = " + name + ", password = " + password);//name = zql, password = 14521} catch (IOException e) {e.printStackTrace();} finally {if(fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}} }

Collections工具類常用方法的測試

package com.atguigu.java;import org.junit.Test;import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List;/*** Collections:操作Collection 和 Map的工具類** 面試題：Collection 和 Collections的區別？* 簡單說一下：*Collection存單列數據的集合接口，包括List和Set。* Collections可操作Collection 。*/ public class CollectionsTest {/* reverse(List)：反轉 List 中元素的順序 shuffle(List)：對 List 集合元素進行隨機排序，隨機換一個順序。 sort(List)：根據元素的自然順序對指定 List 集合元素按升序排序 sort(List，Comparator)：根據指定的 Comparator 產生的順序對 List 集合元素進行排序 swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進行交換Object max(Collection)：根據元素的自然順序，返回給定集合中的最大元素 Object max(Collection，Comparator)：根據 Comparator 指定的順序，返回給定集合中的最大元素 Object min(Collection) Object min(Collection，Comparator) int frequency(Collection，Object)：返回指定集合中指定元素的出現次數 void copy(List dest,List src)：將src中的內容復制到dest中 boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替換 List 對象的所有舊值*/@Testpublic void test2(){List list = new ArrayList();list.add(123);list.add(43);list.add(765);list.add(-97);list.add(0);//報異常：IndexOutOfBoundsException("Source does not fit in dest")//由copy源碼知 因為dest的size是0，list的size是5，size不是指的長度，而時已經填進數組幾個了。//List dest = new ArrayList();//Collections.copy(dest,list);//正確的：List dest = Arrays.asList(new Object[list.size()]);//// 底層是E[] array = new Object[list.size()]，然后返回array的length的值作為size長度。這數組里的五個元素全部默認賦值為null；// 此時array數組長度length是5，那么size等于5，dest.size()就等于了list.size();System.out.println(dest.size());System.out.println(dest);// 5Collections.copy(dest,list);//[null, null, null, null, null]System.out.println(dest);//[123, 43, 765, -97, 0]/*Collections 類中提供了多個 synchronizedXxx() 方法，該方法可使將指定集合包裝成線程同步的集合，從而可以解決多線程并發訪問集合時的線程安全問題*///返回的list1即為線程安全的ListList list1 = Collections.synchronizedList(list);}@Testpublic void test1(){List list = new ArrayList();list.add(123);list.add(43);list.add(765);list.add(765);list.add(765);list.add(-97);list.add(0);System.out.println(list);//[123, 43, 765, 765, 765, -97, 0]//以下4個函數沒有返回值，直接修改的list；//Collections.reverse(list);//反轉 [0, -97, 765, 765, 765, 43, 123]//Collections.shuffle(list);//隨機排序 [765, 0, 765, 765, 43, -97, 123]//Collections.sort(list);//自然排序 [-97, 0, 43, 123, 765, 765, 765]//將指定 list 集合中的 i 處元素和 j 處元素進行交換//Collections.swap(list,1,2);//[123, 765, 43, 765, 765, -97, 0]System.out.println(list);int frequency = Collections.frequency(list, 765);//返回指定集合中指定元素的出現次數System.out.println(frequency);//3 ，出現了3 次}}

總結

以上是生活随笔為你收集整理的JAVA集合4（Map接口）的全部內容，希望文章能夠幫你解決所遇到的問題。

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