文章目錄

• • 類別
  • 體系圖
  • • • ①
      • ②
  • collection常用方法
  • • 代碼
    • Iterator迭代器
    • • 原理
    • 增強for訓練
    • • 基本語法
    • 代碼
    • List接口
    • • 常用方法
      • 案例
  • ArrayList
  • • 底層
  • Vector
  • LinkedList
  • • ArrayList和LinkedList
  • Set接口
  • • 代碼
    • HashSet
    • • 底層機制
    • LinkedHashSet
    • • 底層
  • Map接口
  • • • 補充
      • 小結
      • • **代碼**
      • 常用方法
      • 常用遍歷方法
      • • 代碼
      • 實例
      • HashMap底層機制
      • • 擴容機制與HashSet相同
      • HashTable類（Map接口實現類）
      • • 底層
      • Properties類（Map接口實現類）
      • • 代碼
  • 使用場景
  • TreeSet
  • • 代碼
  • TreeMap
  • • 代碼
  • Collections工具類
  • • 排序操作：（static方法）
    • 查找替換
    • 試分析HashSeti和TreeSets分別如何實現去重的

可以動態保存任意多個對象；提供了一系列方便操作對象的方法

類別

• 集合主要是兩組（單列集合，雙列集合）
• Collection 接口下有兩個重要的子接口 List和Set，他們的實現子類都是單列集合
• Map 接口的實現子類 是雙列集合，存放的 K-V

體系圖

①

②

collection常用方法

代碼

package com.xiaolu.collection_;import java.util.ArrayList; import java.util.List;/*** @author 林小鹿* @version 1.0*/ public class CollectionMethod {@SuppressWarnings({"all"})public static void main(String[] args) {// 說明：以ArrayList實現類來演示List list = new ArrayList();// add添加單個元素, 可以針對不同類型自動裝箱list.add("xiaolu");list.add(10);list.add(true);System.out.println("list=" + list);// remove刪除指定元素 // list.remove(0); // list.remove("xiaolu");// contains查找某個元素是否存在System.out.println(list.contains("xiaolu"));// size:獲取元素個數// isEmpty:判斷是否為空// clear:清空// addAll:添加多個元素ArrayList list2 = new ArrayList();list2.add("三國殺");list2.add("火影忍者");list.addAll(list2);System.out.println("list=" + list);// containsAll:查找多個元素是否都存在// removeAll:刪除多個元素} }

Iterator迭代器

• Iterator對象稱為迭代器，主要用于遍歷Collection集合中的元素
• 所有實現了Collection接口的集合類都有一個Iterator()方法，用于返回一個實現了Iterator接口的對象
• Iterator僅用于遍歷集合，Iterator本身并不存放對象

原理

• Iterator iterator = coll.iterator() // 得到一個集合的迭代器

• hasNext()：判斷是否還有下一個元素

  • while(iterator.hasNext()) {}
  • 快捷鍵：itit
  • idea 顯示所有快捷鍵的提示鍵===> ctrl +j

• next的作用（在調用iterator.next()方法之前必須要調用iterator.hasNext()進檢測，否則下一條記錄無效）

  • 下移
  • 將下移后集合位置上的元素返回

增強for訓練

快捷鍵：I

增強for訓練可以代替iterator迭代器，增強for就是簡化版iterator，本質一樣，主要用于遍歷集合或數組

基本語法

for(元素類型 元素名:集合名或數組名) {

? 訪問元素

}

代碼

package com.xiaolu.collection_;import java.util.ArrayList; import java.util.Collection; import java.util.Iterator;/*** @author 林小鹿* @version 1.0*/ public class CollectionIterator {@SuppressWarnings({"all"})public static void main(String[] args) {Collection col = new ArrayList();col.add(new Book("口水三國",19.9));col.add(new Book("火影忍者",16.1));col.add(new Book("Python",21.9));// System.out.println("list1=" + col);// 1.先得到 col 對應的 迭代器Iterator iterator = col.iterator();// 2.使用while循環遍歷// 快速生成while循環快捷鍵===> itit// 顯示所有快捷鍵的提示鍵===> ctrl +jwhile (iterator.hasNext()) {// 判斷是否還有數據// 返回下一個元素，類型是ObjectObject obj = iterator.next();System.out.println("obj=" + obj);}// 3.當退出while循環后，這時iterator迭代器，指向i最后的元素// 4.如果希望再次遍歷，需要復位重置我們的迭代器iterator = col.iterator();System.out.println("第二次遍歷");while (iterator.hasNext()) {Object obj = iterator.next();System.out.println("obj=" + obj);}System.out.println("增強for");// 增強forfor (Object book :col) {System.out.println("book=" + book);}} }class Book {private String name;private double prices;public Book(String name, double prices) {this.name = name;this.prices = prices;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrices() {return prices;}public void setPrices(double prices) {this.prices = prices;}@Overridepublic String toString() {return "Book{" +"name='" + name + '\'' +", prices='" + prices + '\'' +'}';} }

List接口

• List集合類中元素有序，且可重復
• List集合中的每個元素都有對應的順序索引，即支持索引

常用方法

package com.xiaolu.list_;import java.util.ArrayList; import java.util.List;/*** @author 林小鹿* @version 1.0*/ public class List_ {@SuppressWarnings({"all"})public static void main(String[] args) {List list = new ArrayList();list.add("張三豐");list.add("賈寶玉");// 在index = 1的位置上插入一個對象list.add(1, "林小鹿");List list2 = new ArrayList();list2.add("jack");list2.add("tom");list.addAll(1, list2);System.out.println("list=" + list);// Object get(int index):獲取指定index位置的元素System.out.println(list.get(1));// int indexOf(Object obj):返回obj在集合中首次出現的位置System.out.println(list.indexOf("tom"));// int lastindexOf(Object obj):返回obj在當前集合中末次出現的位置// Object remove(int index):移除指定index位置的元素，并返回此元素// Object set(int index, Object ele):設置指定index位置元素為ele，相當于替換list.set(1, "小米");System.out.println("list=" + list);// List subList(int fromIndex, int toIndex):返回從fromIndex到toIndex位置的子集合(前閉后開)，相當于切片List relist = list.subList(0, 2);System.out.println("relist=" + relist);} }

案例

package com.xiaolu.list_;import java.util.*;/*** @author 林小鹿* @version 1.0*/ @SuppressWarnings({"all"}) public class ListExercise {public static void main(String[] args) {List list = new ArrayList();list.add(new Book("book01", "author01", 100));list.add(new Book("book02", "author02", 10));list.add(new Book("book03", "author03", 12));list.add(new Book("book04", "author04", 80));list.add(new Book("book05", "author05", 52));// 遍歷Iterator iterator = list.iterator();while (iterator.hasNext()) {Object obj = iterator.next();System.out.println(obj);}// 對集合進行冒泡排序sort(list);System.out.println("==排序后==");for (Object o :list) {System.out.println(o);}}// 靜態方法// 要求價格從小到大排序public static void sort(List list) {int size = list.size();for (int i = 0; i < size - 1; i++) {for (int j = 0; j < size - 1 - i; j++) {// 取出object對象并通過向下轉型轉成Book對象Book book01 = (Book) list.get(j);Book book02 = (Book) list.get(j + 1);if (book01.getPrice() > book02.getPrice()) {// 交換list.set(j, book02);list.set(j + 1, book01);}}}}}

ArrayList

• 可以放入任何值，并且可以放多個null
• ArrayList是由數組來實現數據儲存的
• 基本等同于Vector，但ArrayList是線程不安去，且效率高

底層

ArrayList中維護了一個Object類型的數組elementData

• transient Object[] elementData; // transient表示瞬間，短暫的，表示該屬性不會被序列號

當創建ArrayList對象時，如果使用的是無參構造器，則初始elementData容量為0，第1次添加，則擴容elementData為10，如需要再次擴容，則擴容elementData為1.5倍

如果使用的是指定大小的構造器，則初始elementData容量為指定大小，如果需要擴容，則直接擴容elementData為1.5倍

Vector

• 底層也是一個對象數組，protected Object[] elementData;

• Vector 是線程同步，即線程安全，方法帶有synchronized

• 擴容

  • 默認10，滿后按2倍擴容
  • 如果指定大小，則每次直接按2倍擴容

LinkedList

• LinkedList底層實現了雙向鏈表和雙端隊列特點

• 可以添加任意元素（元素可重復）

• 線程不安全

• 底層操作機制

  • LinkedList維護了兩個屬性first和last分別指向首節點和尾節點
  • 每個節點(Node對象)，里面又維護了prev、next、item三個屬性，其中通過prev指向前一個，通過next指向后一個節點
  • 添加和刪除，不是通過數組完成的，效率相對較高

ArrayList和LinkedList

• 如果改查操作多，選擇ArrayList
• 如果增刪LinkedList
• 一般，大部分操作都是查詢，一般是選擇ArrayList，可根據具體的業務需求靈活選擇

Set接口

無序（添加和取出的順序不一致），沒有索引，因此不能使用索引的方式獲取元素

不允許重復的元素出現，最多包含一個null

取出的順序是固定的

代碼

package com.xiaolu.set_;import java.util.HashSet; import java.util.Iterator;/*** @author 林小鹿* @version 1.0*/ public class SetMethod {@SuppressWarnings({"all"})public static void main(String[] args) {// set 接口的實現類的對象，不能存放重復的元素，可添加null// set 接口對象存放數據是無序的HashSet hashSet = new HashSet();hashSet.add("jack");hashSet.add(null);hashSet.add("john");hashSet.add("jack");hashSet.add("amy");System.out.println(hashSet);// 遍歷方式// 1：迭代器System.out.println("===========迭代器=============");Iterator iterator = hashSet.iterator();while (iterator.hasNext()) {Object obj = iterator.next();System.out.println(obj);}hashSet.remove("amy");// 2.增強forSystem.out.println("==========增強for=========");for (Object o : hashSet) {System.out.println(o);}// 無法通過普通for循環，通過索引來獲取} }

HashSet

• 實現類Set接口
• HashSet的底層是HashMap
• 節點 Node
  • value
  • key
  • hash
  • next

底層機制

當向hashset增加一個元素時，會先封裝成一個節點Node，再加入table，size會加一

HashSet的底層是HashMap，

• 第一次添加時，table數組擴容到16，臨界值是16*0.75(加載因子loadFactor) = 12 (threshold)
• 當table數組增加的Node的大小 size 到了臨界值 12，就會擴容到16 * 2 = 32，新臨界值為32*0.75(加載因子) = 24

添加一個元素時，會對hash值進行運算，得到一個索引值（ - 會轉成 -> 索引值）

找到存儲數據表table，看到這個索引位置是否已經存放的有元素

如果沒有直接加入

如果有，調用equals比較，如果相同，就放棄添加，如果不相同，則添加到最后

在java8中，如果一條鏈表的元素個數超過 TREEIFY_THRESHOLD(默認是 8)，并且table的大小 >= MIN_TREEIFY_CAPACITY(默認64)，就會進行樹化(紅黑樹)，否則仍然采用數組擴容機制

LinkedHashSet

加入數據和取出數據順序一致，且不重復

• LinkedHashSet 是 HashSet 的子類
• LinkedHashSet 底層是一個 LinkedHashMap(是HashMap的子類)，底層維護了一個 數組 + 雙向鏈表
• LinkedHashSet 根據元素的 hashCode 值來決定元素的存儲位置，同時使用鏈表維護元素的次序，這使得元素看起來是以插入順序保存的
• LinkedHashSet 不允許添重復元素

底層

• 在 LinkedHashSet 中維護了一個hash表和雙向鏈表(LinkedHashSet 有 head 和 tail)
• 每一個節點有 before 和 after 屬性，這樣可以形成雙向鏈表
• 在添加一個元素時，先求hash值，再求索引，確定該元素在table的位置，然后將添加的元素加入到雙向鏈表(如果已經存在，不添加[原則和hashset一樣])
• 這樣的話，我們遍歷LinkedHashSet 也能確保插入順序和遍歷順序一致

Map接口

Map存放的數據為一對k-v，是放在一個HashMap$Node中的，又因為Node實現了 Entry接口，故一對k-v就是一個Entry，實用性比較高

• Map與Collection并列存在。用于保存具有映射關系的數據：Key-Value(雙列元素)
• Map 中的 key 和 value key是任何引用類型的數據，會封裝到HashMap$Node 對象中
• Map 中的 key 不允許重復，原因和HashSet 一樣，但是value可以重復
  • 當有相同的k時，就等價于替換
• Map的 key為 null，value 也可以為 null，但是key 為null 只能有一個，value可有多個
• 常用String類作為Map的 key
• 通過get 方法，傳入 key ，會返回得到對應的value；通過put進行添加key-value

補充

table里頭存放 k-v ，為了方便遍歷，將其取出，放到Entry中，再放到EntrySet集合中，而key是放在EntrySet中的Set集合，value是放在EntrySet中的Collection集合中

• k-v 最后是 HashMap$Node node = newNode(hash,key,value,null) 出來的
• k-v 為了方便程序員遍歷，還會 創建 EntrySet 集合，該集合存放的元素的類型 Entry，而一個 Entry 對象就有k,v EntrySet<Entry<k,v>> 即： transient Set<Map.Entry<k,v>> entrySet;
• EntrySet 里頭存放的還是Node。entrySet中定義類型是 Map.Entry,但是實際存放的還是 HashMap$Node（為什么EntrySet可以存放Node）這是因為 Node實現了 Entry (static class Node<k,v> implements Map.Entry<k,v>)
• 當把 HashMap$Node 對象 存放到 entrySet 就方便我們的遍歷

小結

• HashMap是Map 接口使用頻率最高的實現類
• 以key-val 對的方式來存儲數據(HashMap$Node類型)
• 允許使用null
• 添加相同的key則會覆蓋（key不會替換，val會替換）
• 與HashSet一樣，不保證映射順序，因為底層是以hash表的方式來存儲
• HashMap沒有實現同步，因此是線程不安全的，方法沒有做同步互斥的操作，沒有關鍵字synchronized

代碼

package com.xiaolu.map_;import java.util.HashMap; import java.util.Map; import java.util.Set;/*** @author 林小鹿* @version 1.0*/ @SuppressWarnings({"all"}) public class MapSource_ {public static void main(String[] args) {Map map = new HashMap();map.put("no1", "林小鹿"); // k-vmap.put("no2", "陳曉霞"); // k-vmap.put("no1", "林曉霞"); // k-v// - k-v 最后是 HashMap$Node node = newNode(hash,key,value,null)//- k-v 為了方便程序員遍歷，還會 創建 EntrySet 集合，該集合存放的元素的類型 Entry，而一個 Entry 對象就有k,v EntrySet<Entry<k,v>> 即： transient Set<Map.Entry<k,v>> entrySet;//- EntrySet 里頭存放的還是Node。entrySet中定義類型是 Map.Entry,但是實際存放的還是 HashMap$Node（為什么EntrySet可以存放Node）這是因為 Node實現了 Entry (static class Node<k,v> implements Map.Entry<k,v>)//- 當把 HashMap$Node 對象 存放到 entrySet 就方便我們的遍歷// K getKey(); V getValue();Set set = map.entrySet();System.out.println(set.getClass());for (Object obj : set) {System.out.println(obj.getClass());// 從HashMap$Node 取出k-v// 先做一個向下轉型Map.Entry entry = (Map.Entry) obj;System.out.println(entry.getKey() + "-" + entry.getValue());}}}

常用方法

put 添加

remove 根據鍵刪除映射關系

get 根據鍵獲取值

size 獲取元素個數

isEmpty 判斷個數是否為0

clear 清除，清空

containsKey 查找鍵是否存在

常用遍歷方法

containsKey 查找鍵是否存在

keySet 獲取所有的鍵

entrySet 獲取所有關系

values 獲取所有的值

代碼

package com.xiaolu.map_;import java.util.*;/*** @author 林小鹿* @version 1.0*/ @SuppressWarnings({"all"}) public class MapFor_ {public static void main(String[] args) {// 遍歷Map map = new HashMap();map.put("no1", "林小鹿"); // k-vmap.put("no2", "陳曉霞"); // k-vmap.put("no1", "林曉霞"); // k-vmap.put(null, "林曉霞"); // k-v// 第一組：先取出 所有的key，通過key 取出對應的ValueSet keyset = map.keySet();// (1) 增強forSystem.out.println("=====方式①=====");for (Object key : keyset) {System.out.println(key + "-" + map.get(key));}// (2)迭代器System.out.println("=====方式②=====");Iterator iterator = keyset.iterator();while (iterator.hasNext()) {Object key = iterator.next();System.out.println(key + "-" + map.get(key));}// 第二組：把所有的value取出Collection values = map.values();// (1)、增強for// (2)、迭代器System.out.println("第三組 通過EntrySet 來獲取 k-v");// 第三組： 通過EntrySet 來獲取 k-vSet entrySet = map.entrySet(); // entrySet集合里面放了Map.Entry ==> EntrySet<Entry<k,v>>// (1) 增強forfor (Object entry : entrySet) {// 由于entrySet集合里面放了Map.Entry，因此需要先向下轉型Map.Entry m = (Map.Entry) entry;System.out.println(m.getKey() + "-" + m.getValue());}// (2) 迭代器Iterator iterator1 = entrySet.iterator();while (iterator1.hasNext()) {Object entry = iterator1.next();System.out.println(entry.getClass()); // HashMap$Node --實現了 Map.Entry接口，因此可以先轉成 Map.Entry再調用 getKey() 和 getValue()Map.Entry m = (Map.Entry) entry;System.out.println(m.getKey() + "-" + m.getValue());}}}

實例

package com.xiaolu.map_;import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set;/*** @author 林小鹿* @version 1.0*/ @SuppressWarnings({"all"}) public class MapExercise01 {public static void main(String[] args) {Map hashMap = new HashMap();hashMap.put(301, new Employee("小紅",301,1900));hashMap.put(302, new Employee("小花",302,8000));hashMap.put(303, new Employee("小綠", 303, 1010));System.out.println("========遍歷一======");Set set = hashMap.keySet();for (Object key : set) {Employee per01 = (Employee) hashMap.get(key);if (per01.getSalary() >= 1800) { // System.out.println(key + "=" + hashMap.get(key));System.out.println(per01);}}System.out.println("++++++++++++++");Iterator iterator = set.iterator();while (iterator.hasNext()) {Object key = iterator.next();System.out.println(key+"="+hashMap.get(key));}System.out.println("========遍歷二======");Set entrySet = hashMap.entrySet();for (Object entry : entrySet) {Map.Entry m = (Map.Entry) entry;System.out.println(m.getKey()+"="+m.getValue());}System.out.println("++++++++++++++");Iterator iterator1 = entrySet.iterator();while (iterator1.hasNext()) {Map.Entry entry = (Map.Entry) iterator1.next();Employee per02 = (Employee) entry.getValue();if (per02.getSalary() >= 1800) { // System.out.println(m.getKey() + "=" + m.getValue());System.out.println(per02);}}}}class Employee {private String name;private int id;private double salary;public Employee(String name, int id, double salary) {this.name = name;this.id = id;this.salary = salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}@Overridepublic String toString() {return "Employee{" +"name='" + name + '\'' +", id=" + id +", salary=" + salary +'}';} }

HashMap底層機制

擴容機制與HashSet相同

• HashMap底層維護了Node類型的數組table，默認為null
• 當創建對象時，將加載因子(loadfactor)初始化為0.75
• 當添加key-val時，通過key的哈希值得到在table的索引。然后判斷該索引處是否有元素，如果沒有元素直接添加。如果該索引處有元素，繼續判斷該元素的key是否和準備加入的key相等。如果添加時發現容量不夠，則需要擴容
• 第一次添加，則需要擴容table容量為16，臨界值(threshold)為12（16*0.75）
• 以后再擴容，則需要擴容table容量為原來的2倍，臨界值為原來的2倍，即24，一次類推。
• 在JAVA8中，如果一條鏈表的元素個數超過TREEIFY_THRESHOLD(默認是8)，并且table的大小 >= MIN_TREEIFY_CAPACITY(默認64)，就會進行樹化(紅黑樹)

HashTable類（Map接口實現類）

• 存放的元素時鍵值對：即 k-v
• hashTable的鍵和值都不能為null
• hashTable 使用方法基本和HashMap一樣
• hashTable 是線程安全的，hashMap 是線程不安全的，但效率比 hashMap 低

底層

• 底層偶遇數組Hashtable$Entry[] 初始化大小為11
• 臨界值（threshold為8=11*0.75）
• 每次擴容值 = 原大小 * 2 + 1

Properties類（Map接口實現類）

• Properties類繼承自Hashtable類并且實現類Map接口，也是使用一種鍵值對的形式來保存數據
• 他的使用特點和Hashtable類似
• Properties還可以用于 從 xxx.properties 文件中，加載數據到Properties類對象，并進行讀取和修改
• 工作中 xxx.properties 文件通常作為配置文件

代碼

package com.xiaolu.map_;import java.util.Properties;/*** @author 林小鹿* @version 1.0* Properties**還可以用于 從 xxx.properties 文件中，加載數據到Properties類對象，并進行讀取和修改* 工作中 xxx.properties 文件通常作為配置文件*/ @SuppressWarnings({"all"}) public class Properties_ {public static void main(String[] args) {// Properties 繼承 Hashtable// 可以通過k-v 存放數據 ，但不能為nullProperties properties = new Properties();// 增加properties.put("john", 100); // k-vproperties.put("lucy", 150);properties.put("aohn", 70);properties.put("john", 10); // 替換properties.put("bohn", 80);System.out.println("properties=" + properties);// 查：通過k 獲取對應值System.out.println(properties.get("lucy"));System.out.println(properties.getProperty("lucy"));// 刪除properties.remove("aohn");System.out.println("properties=" + properties);// 修改properties.put("john", "林校路"); // 原理：替換System.out.println("properties=" + properties);}}

使用場景

主要取決于業務操作特點

• 判斷存儲類型
• 一組對象[單列]：Collection接口
  • 允許重復：List
    • 增刪多：LinkedList [底層維護了一個雙向鏈表]
    • 查改多：ArrayList [底層維護 Object 類型的可變數組]
  • 不允許重復：Set
    • 無序：HashSet [底層是HashMap，維護了一個哈希表 即（數組+鏈表+紅黑樹）]
    • 排序：TreeSet
    • 插入和取出順序一致：LinkedHashSet [底層是LinkedHashMap,再底層是HashMap]，維護數組+雙向鏈表
• 一組鍵值對 [雙列]：Map接口
  • 鍵無序：HashMap [底層是：哈希表 jdk7：數組+鏈表；jdk8 ：數組+鏈表+紅黑樹]
  • 鍵排序：TreeMap
  • 鍵插入和取出順序一致：LinkedHashMap
  • 讀取文件 ： Properties

TreeSet

特點：可定義排序，底層為TreeMap

代碼

package com.xiaolu.set_;import java.util.Comparator; import java.util.TreeSet;/*** @author 林小鹿* @version 1.0*/ @SuppressWarnings({"all"}) public class TreeSet_ {public static void main(String[] args) {// 當使用無參構造器時，創建TreeSet時，仍然是無序的// 若想順序排序，可使用TreeSet 提供的一個構造器，可以傳入一個比較器(匿名內部類)，并指定排序規則// TreeSet treeSet = new TreeSet();TreeSet treeSet = new TreeSet(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {// 下面 調用String的 Comparator方法緊系字符串大小的比較 // return ((String) o1).compareTo((String) o2);// 如果按加入的元素的大小長度來排，則return ((String) o1).length() - ((String) o2).length();}});// 添加數據treeSet.add("jack");treeSet.add("maki");treeSet.add("s");treeSet.add("a");System.out.println("treeSet=" + treeSet);} }/* 底層走的是TreeMap的源碼，因此當 cmp = 0 時，不添加元素 Comparator<? super K> cpr = comparator;if (cpr != null) {do {parent = t;cmp = cpr.compare(key, t.key);if (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;else {V oldValue = t.value;if (replaceOld || oldValue == null) {t.value = value;}return oldValue;}} while (t != null);*/

TreeMap

與TreeSet的區別：為鍵值對，值可變

代碼

package com.xiaolu.set_;import java.util.Comparator; import java.util.TreeSet;/*** @author 林小鹿* @version 1.0*/ @SuppressWarnings({"all"}) public class TreeSet_ {public static void main(String[] args) {// 當使用無參構造器時，創建TreeSet時，仍然是無序的// 若想順序排序，可使用TreeSet 提供的一個構造器，可以傳入一個比較器(匿名內部類)，并指定排序規則// TreeSet treeSet = new TreeSet();TreeSet treeSet = new TreeSet(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {// 下面 調用String的 Comparator方法緊系字符串大小的比較 // return ((String) o1).compareTo((String) o2);// 如果按加入的元素的大小長度來排，則return ((String) o1).length() - ((String) o2).length();}});// 添加數據treeSet.add("jack");treeSet.add("maki");treeSet.add("s");treeSet.add("a");System.out.println("treeSet=" + treeSet);} }/* 1、底層走的是TreeMap的源碼，因此當 cmp = 0 時，不添加元素 Comparator<? super K> cpr = comparator;if (cpr != null) {do {parent = t;cmp = cpr.compare(key, t.key);if (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;else {V oldValue = t.value;if (replaceOld || oldValue == null) {t.value = value;}return oldValue;}} while (t != null);2、調用put方法 2.1 第一次添加，只有一個元素，調用不了比較器把k-v 封裝到 Entry對象，放入root中 Entry<K,V> t = root;if (t == null) {addEntryToEmptyMap(key, value);return null;} 2.2 第二次添加，調用比較器 Comparator<? super K> cpr = comparator; // 比較器if (cpr != null) {do { // 遍歷所有的key，給當前key找適當位置 掛上去parent = t;cmp = cpr.compare(key, t.key); // 動態綁定到我們的匿名內部類的compare方法if (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;else { // 如果遍歷過程中，發現準備添加key 和當前已有的key 相等，就直接返回不添加V oldValue = t.value;if (replaceOld || oldValue == null) {t.value = value;}return oldValue;}} while (t != null);*/

Collections工具類

是一個操作Set、List和Map 等集合的工具類

提供了一系列靜態的方法對集合元素進行排序、查詢和修改等操作

排序操作：（static方法）

• 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 對象的所有舊值

試分析HashSeti和TreeSets分別如何實現去重的

• HashSet的去重機制：hashCode0+equals(0,底層先通過存入對象（key），進行運算得到一個hash值，通過hash值得到對應的索引，如果發現table索引所在的位置，沒有數據，就直接存放，如果有數據，就進行equals比較[遍歷比較]，如果比較后，不相同，就加入，否則就不加入.
• TreeSet的去重機制：如果你傳入了一個Comparator匿名對象，就使用實現的compare去重，如果方法返回0，就認為是相同的元素/數據，就不添加，如果你沒有傳入一個Comparator匿名對象，則以你添加的對象實現的Compareable:接口的compareTo去重.

總結

以上是生活随笔為你收集整理的Java面向对象【集合】的全部內容，希望文章能夠幫你解決所遇到的問題。

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