柚子快報激活碼778899分享：Java 常用類（集合類）
目錄
一、Collection（單列集合）Collection的父接口：Iterable1、List（Collection的子接口、單列集合）1）ArrayList-動態(tài)數(shù)組-線程不安全2）Vector-線程安全3）LinkedList-鏈表(可以實現(xiàn)棧和隊列)-線程不安全
2、Set（Collection的子接口、單列集合）1）HashSet2）LinkedHashSet3）TreeSet
二、Map（雙列集合、存放的K-V）1、HashMap2、LinkedHashMap3、Hashtable4、Properties5、TreeMap
三、Collections-Collection的幫助類四、Arrays-數(shù)組的幫助類
一、Collection（單列集合）
Collection的父接口：Iterable
Iterable中有個重要方法：iterator()；，其作用是可以返回一個Iterator對象（Iterator類本身也是一個接口，其中有hasNext()及next()方法用于對集合元素進(jìn)行操作），也就是迭代器對象（迭代器對象可以對單列集合中所有元素進(jìn)行遍歷）。故，只要實現(xiàn)了Collection接口的子類，都可以去獲取到一個迭代器來遍歷集合中所有元素。
基本介紹 1）Iterator對象稱為迭代器，主要用于遍歷Collection集合中的元素； 2）所有實現(xiàn)了Collection接口的集合類都有一個iterator()方法，用以返回一個實現(xiàn)了Iterator接口的對象，即可以返回一個迭代器； 3）Iterator對象就相當(dāng)于一個指針，hasNext()方法用于判斷是否還有下一個元素；next()方法的作用是讓指針下移并返回集合位置上的元素；【注意：在調(diào)用next()方法前必須要調(diào)用hasNext()進(jìn)行檢測。若不調(diào)用，當(dāng)下一條記錄無效時，直接調(diào)用next()就會拋出NoSuchElementException異常】 4）Iterator僅用于遍歷集合，Iterator本身并不存放對象
Collection接口遍歷元素方式1-使用Iterator（迭代器）：
package com.hspedu.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("三國演義", "羅貫中", 10.1));
col.add(new Book("小李飛刀", "古龍", 5.1));
col.add(new Book("紅樓夢", "曹雪芹", 34.6));
//System.out.println("col=" + col);
//現(xiàn)在老師希望能夠遍歷 col集合
//1. 先得到 col 對應(yīng)的 迭代器
Iterator iterator = col.iterator();
//2. 使用while循環(huán)遍歷
// while (iterator.hasNext()) {//判斷是否還有數(shù)據(jù)
// //返回下一個元素，類型是Object
// Object obj = iterator.next();
// System.out.println("obj=" + obj);
// }
//老師教大家一個快捷鍵，快速生成 while => itit
//顯示所有的快捷鍵的的快捷鍵 ctrl + j
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
//3. 當(dāng)退出while循環(huán)后 , 這時iterator迭代器，指向最后的元素
// iterator.next();//NoSuchElementException
//4. 如果希望再次遍歷，需要重置我們的迭代器
iterator = col.iterator();
System.out.println("===第二次遍歷===");
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
}
}
class Book {
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
重置迭代器是通過單列集合對象再次調(diào)用iterator()方法實現(xiàn)，相當(dāng)于把迭代器中的指針/游標(biāo)放到最前面的位置
Collection接口遍歷元素方式2-for循環(huán)增強： 增強for循環(huán)，可以代替iterator迭代器，特點：增強for就是簡化版的iterator，本質(zhì)一樣。只能用于遍歷集合或數(shù)組。
基本語法 for(元素類型 元素名 : 集合名或數(shù)組名){ ????訪問元素 }
package com.hspedu.collection_;
import java.util.ArrayList;
import java.util.Collection;
/**
* @author 韓順平
* @version 1.0
*/
public class CollectionFor {
@SuppressWarnings({"all"})
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三國演義", "羅貫中", 10.1));
col.add(new Book("小李飛刀", "古龍", 5.1));
col.add(new Book("紅樓夢", "曹雪芹", 34.6));
//老韓解讀
//1. 使用增強for, 在Collection集合
//2. 增強for， 底層仍然是迭代器
//3. 增強for可以理解成就是簡化版本的 迭代器遍歷
//4. 快捷鍵方式 I
// for (Object book : col) {
// System.out.println("book=" + book);
// }
for (Object o : col) {
System.out.println("book=" + o);
}
//增強for，也可以直接在數(shù)組使用
// int[] nums = {1, 8, 10, 90};
// for (int i : nums) {
// System.out.println("i=" + i);
// }
}
}
Collection接口遍歷元素方式3-普通for循環(huán)：（注意：對于Set接口的實現(xiàn)類不能使用這種方法進(jìn)行遍歷，因為其無法獲取索引）
package com.hspedu.list_;
import java.util.*;
/**
* @author 韓順平
* @version 1.0
*/
public class ListFor {
@SuppressWarnings({"all"})
public static void main(String[] args) {
//List 接口的實現(xiàn)子類 Vector LinkedList
//List list = new ArrayList();
//List list = new Vector();
List list = new LinkedList();
list.add("jack");
list.add("tom");
list.add("魚香肉絲");
list.add("北京烤鴨子");
//遍歷
//1. 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("=====增強for=====");
//2. 增強for
for (Object o : list) {
System.out.println("o=" + o);
}
System.out.println("=====普通for====");
//3. 使用普通for
for (int i = 0; i < list.size(); i++) {
System.out.println("對象=" + list.get(i));
}
}
}
Collection方法（以ArrayList為例演示Collection接口中的一些常用方法）： Collection接口沒有直接的實現(xiàn)子類，是通過它的子接口Set和List來實現(xiàn)的。
package com.hspedu.collection_;
import java.util.ArrayList;
import java.util.List;
/**
* @author 韓順平
* @version 1.0
*/
public class CollectionMethod {
@SuppressWarnings({"all"})
public static void main(String[] args) {
List list = new ArrayList();
// add:添加單個元素
list.add("jack");
list.add(10);//list.add(new Integer(10))
list.add(true);
System.out.println("list=" + list);
// remove:刪除指定元素
list.remove(0);//刪除第一個元素
list.remove(true);//指定刪除某個元素
System.out.println("list=" + list);
// contains:查找元素是否存在
System.out.println(list.contains("jack"));//T
// size:獲取元素個數(shù)
System.out.println(list.size());//2
// isEmpty:判斷是否為空
System.out.println(list.isEmpty());//F
// clear:清空
// list.clear();
System.out.println("list=" + list);
// addAll:添加多個元素
ArrayList list2 = new ArrayList();
list2.add("紅樓夢");
list2.add("三國演義");
list.addAll(list2);
System.out.println("list=" + list);
// containsAll:查找多個元素是否都存在
System.out.println(list.containsAll(list2));//T
// removeAll：刪除多個元素
list.add("聊齋");
list.removeAll(list2);
System.out.println("list=" + list);//[聊齋]
// 說明：以ArrayList實現(xiàn)類來演示.
}
}
1、List（Collection的子接口、單列集合）
List：有序（指存放和取出的順序是一致的）、可重復(fù)
List方法（以ArrayList為例演示List接口中的一些常用方法）：
package com.hspedu.list_;
import java.util.ArrayList;
import java.util.List;
/**
* @author 韓順平
* @version 1.0
*/
public class ListMethod {
@SuppressWarnings({"all"})
public static void main(String[] args) {
List list = new ArrayList();
list.add("張三豐");
list.add("賈寶玉");
// void add(int index, Object ele):在index位置插入ele元素
//在index = 1的位置插入一個對象
list.add(1, "韓順平");
System.out.println("list=" + list);
// boolean addAll(int index, Collection eles):從index位置開始將eles中的所有元素添加進(jìn)來
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1, list2);
System.out.println("list=" + list);
// Object get(int index):獲取指定index位置的元素
//說過
// int indexOf(Object obj):返回obj在集合中首次出現(xiàn)的位置
System.out.println(list.indexOf("tom"));//2
// int lastIndexOf(Object obj):返回obj在當(dāng)前集合中末次出現(xiàn)的位置
list.add("韓順平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韓順平"));
// Object remove(int index):移除指定index位置的元素，并返回此元素
list.remove(0);
System.out.println("list=" + list);
// Object set(int index, Object ele):設(shè)置指定index位置的元素為ele , 相當(dāng)于是替換.
// 指定的index位置必須要有對象，否則會報空指針異常
list.set(1, "瑪麗");
System.out.println("list=" + list);
// List subList(int fromIndex, int toIndex):返回從fromIndex到toIndex位置的子集合
// 注意返回的子集合 fromIndex <= subList < toIndex；前閉后開
List returnlist = list.subList(0, 2);
System.out.println("returnlist=" + returnlist);
}
}
List的三種遍歷方式[ArrayList, LinkedList, Vector]
方式一：使用iterator方式二：使用增強for方式三：使用普通for
1）ArrayList-動態(tài)數(shù)組-線程不安全
基本介紹 1）ArrayList可以加入null（多個也可）； 2）ArrayList是由數(shù)組來實現(xiàn)數(shù)據(jù)存儲的； 3）ArrayList基本等同于Vector，除了ArrayList是線程不安全的（執(zhí)行效率高），在多線程情況下，不建議使用ArrayList，可以用Vector 常用方法 1）add（）：添加單個元素 2）remove(Object obj) 刪除元素 3）size（）：集合元素個數(shù) 底層結(jié)構(gòu)&源碼分析 1）ArrayList中維護(hù)了一個object類型的數(shù)組elementData； transient Object[] elementData；//transient 表示瞬間，短暫的，表示該屬性不能被序列化； 2）當(dāng)創(chuàng)建ArrayList對象時，如果使用的是無參構(gòu)造器，則初始elementData容量為0，第一次添加，則擴容elementData為10，如果需要再次擴容，則擴容elementData為1.5倍； 3）如果使用的是指定大小的構(gòu)造器，則初始elementData容量為指定大小，如果需要擴容，則直接擴容elementData為1.5倍
2）Vector-線程安全
基本介紹 1）Vector類的定義說明 2）Vector底層也是一個對象數(shù)組，protected Object[] elementData; 3）Vector是線程同步的，即線程安全，Vector類的操作方法帶有synchronized 4）在開發(fā)中，需要線程同步安全時，考慮使用Vector 底層結(jié)構(gòu)&源碼分析 如果是無參，默認(rèn)為10，滿后，就按2倍擴容；如果指定大小，則每次直接按2倍擴
3）LinkedList-鏈表(可以實現(xiàn)棧和隊列)-線程不安全
add（）：添加元素【無擴容機制】 remove(Object obj) 刪除元素 size（）：集合元素個數(shù)
底層結(jié)構(gòu)&源碼分析
總結(jié) List集合選擇 1.Vector和ArrayList的比較 2.ArrayList和LinkedList的比較 如何選擇ArrayList和LinkedList： 1）如果我們改查的操作多，選擇ArrayList 2）如果我們增刪的操作多，選擇LinkedList 3）一般來說，在程序中，80%-90%都是查詢，因此大部分情況下會選擇ArrayList 4）在一個項目中，根據(jù)業(yè)務(wù)靈活選擇，也可能這樣，一個模塊使用的是ArrayList，另外一個模塊是LinkedList
2、Set（Collection的子接口、單列集合）
Set：無序（指添加和取出的順序不是一致的），沒有索引、不可重復(fù)
Set方法（以HashSet為例演示Set接口中的一些常用方法）：
package com.hspedu.set_;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* @author 韓順平
* @version 1.0
*/
@SuppressWarnings({"all"})
public class SetMethod {
public static void main(String[] args) {
//老韓解讀
//1. 以Set 接口的實現(xiàn)類 HashSet 來講解Set 接口的方法
//2. set 接口的實現(xiàn)類的對象(Set接口對象), 不能存放重復(fù)的元素, 可以添加一個null
//3. set 接口對象存放數(shù)據(jù)是無序(即添加的順序和取出的順序不一致)
//4. 注意：取出的順序雖然不是添加的順序，但是他是固定的.
Set set = new HashSet();
set.add("john");
set.add("lucy");
set.add("john");//重復(fù)
set.add("jack");
set.add("hsp");
set.add("mary");
set.add(null);//
set.add(null);//再次添加null
for(int i = 0; i <10;i ++) {
System.out.println("set=" + set);
}
//遍歷
//方式1： 使用迭代器
System.out.println("=====使用迭代器====");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
set.remove(null);
//方式2: 增強for
System.out.println("=====增強for====");
for (Object o : set) {
System.out.println("o=" + o);
}
//set 接口對象，不能通過索引來獲取
}
}
1）HashSet
說明 1）HashSet實現(xiàn)了Set接口 2）HashSet實際上是HashMap（HashSet底層是HashMap，HashMap底層是（數(shù)組+鏈表+紅黑樹））【當(dāng)鏈表達(dá)到一定量且滿足數(shù)組的大小在某一個范圍時，底層就會將鏈表進(jìn)行一個樹化，變成一顆紅黑樹】 3）可以存放null值，但是只能有一個null 4）HashSet不保證元素是有序的，取決于hash后，再確定索引的結(jié)果（即，不保證存放元素的順序和取出順序一致） 5）不能有重復(fù)元素/對象 HashSet底層機制 1.HashSet底層是HashMap 2.添加一個元素時，先得到hash值并通過算法（為了防止沖突）轉(zhuǎn)成索引值 3.找到存儲數(shù)據(jù)表table，看這個索引位置是否已經(jīng)存放元素 4.如果沒有，直接加入 5.如果有，調(diào)用equals（程序員可通過重寫equals方法進(jìn)行控制）比較，如果相同則放棄添加，如果不相同則添加到鏈表最后 6.在Java8中，如果一條鏈表的元素個數(shù) > TREEIFY_THRESHOLD（默認(rèn)是8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默認(rèn)64），就會進(jìn)行樹化（紅黑樹） HashSet擴容及轉(zhuǎn)成紅黑樹機制 1.HashSet底層是HashMap，第一次添加時，table數(shù)組擴容到16，臨界值（threshold）是16*加載因子（loadFactor）0.75=12【注：計算是否達(dá)到臨界值時并不只局限于每一個鏈表中的第一個元素】 2.如果table數(shù)組使用超過臨界值12，就會擴容到 16 * 2 = 32，新的臨界值就是 32 * 0.75 = 24，依此類推 3.在Java8中，如果一條鏈表的元素個數(shù)超過TREEIFY_THRESHOLD（默認(rèn)是8），并且 table的大小>=MIN_TREEIFY_CAPACITY（默認(rèn)64），就會進(jìn)行樹化（紅黑樹）（樹化時會將所有元素重構(gòu)一遍，故所有元素個數(shù)超過8的鏈表都將會進(jìn)行樹化），否則仍然采用數(shù)組擴容機制 源碼：
import java.util.HashSet;
@SuppressWarnings({"all"})
public class HashSetSource {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");//到此位置，第1次add分析完畢.
hashSet.add("php");//到此位置，第2次add分析完畢
hashSet.add("java");
System.out.println("set=" + hashSet);
/*
老韓對HashSet 的源碼解讀
1. 執(zhí)行 HashSet()
public HashSet() {
map = new HashMap<>();
}
2. 執(zhí)行 add()
public boolean add(E e) {//e = "java"
return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
}
3.執(zhí)行 put() , 該方法會執(zhí)行 hash(key) 得到key對應(yīng)的hash值 算法h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//key = "java" 變化；value = PRESENT 不變，共享，value充當(dāng)?shù)氖钦嘉坏淖饔?，其目的是為了set能在底層使用map
return putVal(hash(key), key, value, false, true);
}
4.執(zhí)行 putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node
//table 就是 HashMap 的一個屬性，類型是 Node[]
//if 語句表示如果當(dāng)前table 是null, 或者 大小=0
//就是第一次擴容，到16個空間.
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(1)根據(jù)key，得到hash 去計算該key應(yīng)該存放到table表的哪個索引位置
//并把這個位置的對象，賦給 p
//(2)判斷p 是否為null
//(2.1) 如果p 為null, 表示還沒有存放元素, 就創(chuàng)建一個Node (key="java",value=PRESENT)
//(2.2) 就放在該位置 tab[i] = newNode(hash, key, value, null)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//一個開發(fā)技巧提示： 在需要局部變量(輔助變量)時候，再創(chuàng)建
Node
//如果當(dāng)前索引位置對應(yīng)的鏈表的第一個元素和準(zhǔn)備添加的key的hash值一樣
//并且滿足 下面兩個條件之一:
//(1) 準(zhǔn)備加入的key 和 p 指向的Node 結(jié)點的 key 是同一個對象
//(2) p 指向的Node 結(jié)點的 key 的equals() 和準(zhǔn)備加入的key比較后相同
//就不能加入
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//再判斷 p 是不是一顆紅黑樹,
//如果是一顆紅黑樹，就調(diào)用 putTreeVal , 來進(jìn)行添加
else if (p instanceof TreeNode)
e = ((TreeNode
else {//如果table對應(yīng)索引位置，已經(jīng)是一個鏈表, 就使用for循環(huán)比較
//(1) 依次和該鏈表的每一個元素比較后，都不相同, 則加入到該鏈表的最后
// 注意在把元素添加到鏈表后，立即判斷 該鏈表是否已經(jīng)達(dá)到8個結(jié)點
// , 就調(diào)用 treeifyBin() 對當(dāng)前這個鏈表進(jìn)行樹化(轉(zhuǎn)成紅黑樹)
// 注意，在轉(zhuǎn)成紅黑樹時，要進(jìn)行判斷, 判斷條件
// if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
// resize();
// 如果上面條件成立，先table擴容.
// 只有上面條件不成立時，才進(jìn)行樹化（轉(zhuǎn)成紅黑樹）
//(2) 依次和該鏈表的每一個元素比較過程中，如果有相同情況,就直接break
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD(8) - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//size 就是我們每加入一個結(jié)點Node(k,v,h,next), size++
if (++size > threshold)
resize();//擴容
afterNodeInsertion(evict);
return null;
}
*/
}
}
對于HashSet不能放重復(fù)元素這點，有個非常經(jīng)典的面試題：
import java.util.HashSet;
@SuppressWarnings({"all"})
public class HashSet01 {
public static void main(String[] args) {
HashSet set = new HashSet();
//說明
//1. 在執(zhí)行add方法后，會返回一個boolean值
//2. 如果添加成功，返回 true, 否則返回false
//3. 可以通過 remove 指定刪除哪個對象
System.out.println(set.add("john"));//T
System.out.println(set.add("lucy"));//T
System.out.println(set.add("john"));//F
System.out.println(set.add("jack"));//T
System.out.println(set.add("Rose"));//T
set.remove("john");
System.out.println("set=" + set);//3個
//
set = new HashSet();
System.out.println("set=" + set);//0
//4 Hashset 不能添加相同的元素/數(shù)據(jù)?
set.add("lucy");//添加成功
set.add("lucy");//加入不了
set.add(new Dog("tom"));//OK
set.add(new Dog("tom"));//Ok
System.out.println("set=" + set);
//在加深一下. 非常經(jīng)典的面試題.
//看源碼，做分析， 先給小伙伴留一個坑，以后講完源碼，你就了然
//去看他的源碼，即 add 到底發(fā)生了什么?=> 底層機制.
set.add(new String("hsp"));//ok
set.add(new String("hsp"));//加入不了.
System.out.println("set=" + set);
}
}
class Dog { //定義了Dog類
private String name;
public Dog(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
練習(xí)
/**
* @authos Kim
* @version 1.8
*/
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
/**
* @version 1.8
* @authos Kim
*/
public class Test {
public static void main(String[] args) {
HashSet
dogs.add(new Dog("k",18,new MyDate(12,1,1)));
dogs.add(new Dog("d",18,new MyDate(12,1,1)));
dogs.add(new Dog("k",18,new MyDate(12,1,1)));
Iterator
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
class Dog{
String name;
int age;
MyDate myDate;
public Dog() {
}
public Dog(String name, int age, MyDate myDate) {
this.name = name;
this.age = age;
this.myDate = myDate;
}
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;
}
public MyDate getMyDate() {
return myDate;
}
public void setMyDate(MyDate myDate) {
this.myDate = myDate;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", myDate=" + myDate +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Dog dog = (Dog) o;
return age == dog.age && Objects.equals(name, dog.name) && Objects.equals(myDate, dog.myDate);
}
@Override
public int hashCode() {
return Objects.hash(name, age, myDate);
}
}
class MyDate{
int year;
int month;
int day;
public MyDate() {
}
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyDate myDate = (MyDate) o;
return year == myDate.year && month == myDate.month && day == myDate.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
}
2）LinkedHashSet
全面說明 1.LinkedHashSet是HashSet的子類; 2.LinkedHashSet底層是一個LinkedHashMap,底層維護(hù)了一個數(shù)組+雙向鏈表+紅黑樹; 3.LinkedHashSet根據(jù)元素的hashcode值來決定元素的存儲位置,同時使用鏈表維護(hù)元素的次序（圖）,是元素看起來以插入順序保存; 4.LinkedHashSet不允許添加重復(fù)元素 源碼
import java.util.LinkedHashSet;
import java.util.Set;
@SuppressWarnings({"all"})
public class LinkedHashSetSource {
public static void main(String[] args) {
//分析一下LinkedHashSet的底層機制
Set set = new LinkedHashSet();
set.add(new String("AA"));
set.add(456);
set.add(456);
set.add(new Customer("劉", 1001));
set.add(123);
set.add("HSP");
System.out.println("set=" + set);
//老韓解讀
//1. LinkedHashSet 加入順序和取出元素/數(shù)據(jù)的順序一致
//2. LinkedHashSet 底層維護(hù)的是一個 LinkedHashMap(是HashMap的子類)
//3. LinkedHashSet 底層結(jié)構(gòu) (數(shù)組table+雙向鏈表)
//4. 添加第一次時，直接將 數(shù)組table 擴容到 16 ,存放的結(jié)點類型是 LinkedHashMap$Entry
//5. 數(shù)組是 HashMap$Node[] 存放的元素/數(shù)據(jù)是 LinkedHashMap$Entry類型
/*
//繼承關(guān)系是在內(nèi)部類完成.
static class Entry
Entry
Entry(int hash, K key, V value, Node
super(hash, key, value, next);
}
}
*/
}
}
class Customer {
private String name;
private int no;
public Customer(String name, int no) {
this.name = name;
this.no = no;
}
}
練習(xí)
import java.util.LinkedHashSet;
import java.util.Objects;
@SuppressWarnings({"all"})
public class LinkedHashSetExercise {
public static void main(String[] args) {
LinkedHashSet linkedHashSet = new LinkedHashSet();
linkedHashSet.add(new Car("奧拓", 1000));//OK
linkedHashSet.add(new Car("奧迪", 300000));//OK
linkedHashSet.add(new Car("法拉利", 10000000));//OK
linkedHashSet.add(new Car("奧迪", 300000));//加入不了
linkedHashSet.add(new Car("保時捷", 70000000));//OK
linkedHashSet.add(new Car("奧迪", 300000));//加入不了
System.out.println("linkedHashSet=" + linkedHashSet);
}
}
/**
* Car 類(屬性:name,price)， 如果 name 和 price 一樣，
* 則認(rèn)為是相同元素，就不能添加。 5min
*/
class Car {
private String name;
private double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "\nCar{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
//重寫equals 方法 和 hashCode
//當(dāng) name 和 price 相同時， 就返回相同的 hashCode 值, equals返回t
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return Double.compare(car.price, price) == 0 &&
Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
}
3）TreeSet
???????????TreeSet 底層維護(hù)的是一個 TreeMap
示例代碼：
import java.util.Comparator;
import java.util.TreeSet;
@SuppressWarnings({"all"})
public class TreeSet_ {
public static void main(String[] args) {
//老韓解讀
//1. 當(dāng)我們使用無參構(gòu)造器創(chuàng)建TreeSet時，是按照key值默認(rèn)的排序規(guī)則進(jìn)行排序的
//2. 老師希望添加的元素，按照字符串大小來排序
//3. 使用TreeSet 提供的一個構(gòu)造器，可以傳入一個比較器(匿名內(nèi)部類)
// 并指定排序規(guī)則
//4. 簡單看看源碼
//老韓解讀
/*
1. 構(gòu)造器把傳入的比較器對象，賦給了 TreeSet的底層的 TreeMap的屬性this.comparator
public TreeMap(Comparator comparator) {
this.comparator = comparator;
}
2. 在 調(diào)用 treeSet.add("tom"), 在底層會執(zhí)行到
if (cpr != null) {//cpr 就是我們的匿名內(nèi)部類(對象)
do {
parent = t;
//動態(tài)綁定到我們的匿名內(nèi)部類(對象)compare
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else //如果相等，即返回0,這個Key就沒有加入
return t.setValue(value);
} while (t != null);
}
*/
TreeSet treeSet = new TreeSet();
// TreeSet treeSet = new TreeSet(new Comparator() {
// @Override
// public int compare(Object o1, Object o2) {
// //下面 調(diào)用String的 compareTo方法進(jìn)行字符串大小比較
// //如果老韓要求加入的元素，按照長度大小排序
// //return ((String) o2).compareTo((String) o1);
// return ((String) o1).length() - ((String) o2).length();
// }
// });
//添加數(shù)據(jù).
treeSet.add("jack");
treeSet.add("tom");//3
treeSet.add("sp");
treeSet.add("a");
treeSet.add("abc");//3
System.out.println("treeSet=" + treeSet);
}
}
TreeSet 不能放 null 值
二、Map（雙列集合、存放的K-V）
Map：key不可重復(fù)，無序（指添加和取出的順序不是一致的）
Map接口特點（以HashMap為例演示Map接口中的特點）：
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings({"all"})
public class Map_ {
public static void main(String[] args) {
//老韓解讀Map 接口實現(xiàn)類的特點, 使用實現(xiàn)類HashMap
//1. Map與Collection并列存在。用于保存具有映射關(guān)系的數(shù)據(jù):Key-Value(雙列元素)
//2. Map 中的 key 和 value 可以是任何引用類型的數(shù)據(jù)，會封裝到HashMap$Node 對象中
//3. Map 中的 key 不允許重復(fù)，原因和HashSet 一樣，前面分析過源碼.
//4. Map 中的 value 可以重復(fù)
//5. Map 的key 可以為 null, value 也可以為null ，注意 key 為null,
// 只能有一個，value 為null ,可以多個
//6. 常用String類作為Map的 key
//7. key 和 value 之間存在單向一對一關(guān)系，即通過指定的 key 總能找到對應(yīng)的 value
Map map = new HashMap();
map.put("no1", "韓順平");//k-v
map.put("no2", "張無忌");//k-v
map.put("no1", "張三豐");//當(dāng)有相同的k , 就等價于替換.
map.put("no3", "張三豐");//k-v
map.put(null, null); //k-v
map.put(null, "abc"); //等價替換
map.put("no4", null); //k-v
map.put("no5", null); //k-v
map.put(1, "趙敏");//k-v
map.put(new Object(), "金毛獅王");//k-v
// 通過get 方法，傳入 key ,會返回對應(yīng)的value
System.out.println(map.get("no2"));//張無忌
System.out.println("map=" + map);
}
}
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
@SuppressWarnings({"all"})
public class MapSource_ {
public static void main(String[] args) {
Map map = new HashMap();
map.put("no1", "韓順平");//k-v
map.put("no2", "張無忌");//k-v
map.put(new Car(), new Person());//k-v
//老韓解讀
//1. k-v 最后是 HashMap$Node node = newNode(hash, key, value, null)
//2. k-v 為了方便程序員的遍歷，還會 創(chuàng)建 EntrySet 集合 ，該集合存放的元素的類型 Entry, 而一個Entry
// 對象就有k,v EntrySet
//3. entrySet 中， 定義的類型是 Map.Entry ，但是實際上存放的還是 HashMap$Node
// 這是因為 static class Node
//4. 當(dāng)把 HashMap$Node 對象 存放到 entrySet 就方便我們的遍歷, 因為 Map.Entry 提供了重要方法
// K getKey(); V getValue();
Set set = map.entrySet();
System.out.println(set.getClass());// HashMap$EntrySet
for (Object obj : set) {
//System.out.println(obj.getClass()); //HashMap$Node
//為了從 HashMap$Node 取出k-v
//1. 先做一個向下轉(zhuǎn)型
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "-" + entry.getValue() );
}
Set set1 = map.keySet();
System.out.println(set1.getClass());
Collection values = map.values();
System.out.println(values.getClass());
}
}
class Car {
}
class Person{
}
Map方法（以HashMap為例演示Map接口中的一些常用方法）：
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings({"all"})
public class MapMethod {
public static void main(String[] args) {
//演示map接口常用方法
Map map = new HashMap();
map.put("鄧超", new Book("", 100));//OK
map.put("鄧超", "孫儷");//替換-> 一會分析源碼
map.put("王寶強", "馬蓉");//OK
map.put("宋喆", "馬蓉");//OK
map.put("劉令博", null);//OK
map.put(null, "劉亦菲");//OK
map.put("鹿晗", "關(guān)曉彤");//OK
map.put("hsp", "hsp的老婆");
System.out.println("map=" + map);
// remove:根據(jù)鍵刪除映射關(guān)系
map.remove(null);
System.out.println("map=" + map);
// get：根據(jù)鍵獲取值
Object val = map.get("鹿晗");
System.out.println("val=" + val);
// size:獲取元素個數(shù)
System.out.println("k-v=" + map.size());
// isEmpty:判斷個數(shù)是否為0
System.out.println(map.isEmpty());//F
// clear:清除k-v
//map.clear();
System.out.println("map=" + map);
// containsKey:查找鍵是否存在
System.out.println("結(jié)果=" + map.containsKey("hsp"));//T
}
}
class Book {
private String name;
private int num;
public Book(String name, int num) {
this.name = name;
this.num = num;
}
}
Map遍歷方式（以HashMap為例）：
import java.util.*;
@SuppressWarnings({"all"})
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("鄧超", "孫儷");
map.put("王寶強", "馬蓉");
map.put("宋喆", "馬蓉");
map.put("劉令博", null);
map.put(null, "劉亦菲");
map.put("鹿晗", "關(guān)曉彤");
//第一組: 先取出 所有的Key , 通過Key 取出對應(yīng)的Value
Set keyset = map.keySet();
//(1) 增強for
System.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));
}
//第二組: 把所有的values取出
Collection values = map.values();
//這里可以使用所有的Collections使用的遍歷方法
//(1) 增強for
System.out.println("---取出所有的value 增強for----");
for (Object value : values) {
System.out.println(value);
}
//(2) 迭代器
System.out.println("---取出所有的value 迭代器----");
Iterator iterator2 = values.iterator();
while (iterator2.hasNext()) {
Object value = iterator2.next();
System.out.println(value);
}
//第三組: 通過EntrySet 來獲取 k-v
Set entrySet = map.entrySet();// EntrySet
//(1) 增強for
System.out.println("----使用EntrySet 的 for增強(第3種)----");
for (Object entry : entrySet) {
//將entry 轉(zhuǎn)成 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2) 迭代器
System.out.println("----使用EntrySet 的 迭代器(第4種)----");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object entry = iterator3.next();
//System.out.println(next.getClass());//HashMap$Node -實現(xiàn)-> Map.Entry (getKey,getValue)
//向下轉(zhuǎn)型 Map.Entry
Map.Entry m = (Map.Entry) entry;
// 為什么不能強轉(zhuǎn)為 HashMap.Node 類型？？？
// HashMap$Node的修飾符為default，其修飾范圍只在本包內(nèi)
System.out.println(m.getKey() + "-" + m.getValue());
}
}
}
1、HashMap
底層機制 1）HashMap底層維護(hù)了Node類型的數(shù)組table，默認(rèn)為null 2）當(dāng)創(chuàng)建對象時，將加載因子（loadfactor）初始化為0.75 3）當(dāng)添加key-val時，通過key的哈希值得到在table的索引。然后判斷該索引處是否有元素，如果沒有元素直接添加。如果該索引處有元素，判斷該元素的key和準(zhǔn)備加入的key是否相等。如果相等，則直接替換val，如果不相等需要判斷是樹結(jié)構(gòu)還是鏈表結(jié)構(gòu)從而做出相應(yīng)處理。如果添加時發(fā)現(xiàn)容量不夠，則需要擴容。 4）第1添加，則需要擴容table容量為16，臨界值（threshold）為12（16*0.75） 5）以后再擴容，則需要擴容table容量為原來的2倍（32），臨界值為原來的2倍，即24。依此類推 6）在Java8中，如果一條鏈表的元素個數(shù)超過TREEIFY_THRESHOLD（默認(rèn)是8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默認(rèn)64），就會進(jìn)行樹化（紅黑樹）源碼剖析
import java.util.HashMap;
@SuppressWarnings({"all"})
public class HashMapSource1 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("java", 10);//ok
map.put("php", 10);//ok
map.put("java", 20);//替換value
System.out.println("map=" + map);//
/*老韓解讀HashMap的源碼+圖解
1. 執(zhí)行構(gòu)造器 new HashMap()
初始化加載因子 loadfactor = 0.75
HashMap$Node[] table = null
2. 執(zhí)行put 調(diào)用 hash方法，計算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//key = "java" value = 10
return putVal(hash(key), key, value, false, true);
}
3. 執(zhí)行 putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node
//如果底層的table 數(shù)組為null, 或者 length =0 , 就擴容到16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//取出hash值對應(yīng)的table的索引位置的Node, 如果為null, 就直接把加入的k-v
//, 創(chuàng)建成一個 Node ,加入該位置即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node
// 如果table的索引位置的key的hash相同和新的key的hash值相同，
// 并 滿足(table現(xiàn)有的結(jié)點的key和準(zhǔn)備添加的key是同一個對象 || equals返回真)
// 就認(rèn)為不能加入新的k-v
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) // key != null 避免出現(xiàn)空指針異常
e = p;
else if (p instanceof TreeNode)//如果當(dāng)前的table的已有的Node 是紅黑樹，就按照紅黑樹的方式處理
e = ((TreeNode
else {
//如果找到的結(jié)點，后面是鏈表，就循環(huán)比較
for (int binCount = 0; ; ++binCount) {//死循環(huán)
if ((e = p.next) == null) {//如果整個鏈表，沒有和他相同,就加到該鏈表的最后
p.next = newNode(hash, key, value, null);
//加入后，判斷當(dāng)前鏈表的個數(shù)，是否已經(jīng)到8個，到8個后
//就調(diào)用 treeifyBin 方法進(jìn)行紅黑樹的轉(zhuǎn)換
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && //如果在循環(huán)比較過程中，發(fā)現(xiàn)有相同,就break,就只是替換value
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; //替換，key對應(yīng)value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//每增加一個Node ,就size++
if (++size > threshold[12-24-48])//如size > 臨界值，就擴容
resize();
afterNodeInsertion(evict);
return null;
}
5. 關(guān)于樹化(轉(zhuǎn)成紅黑樹)
//如果table 為null ,或者大小還沒有到 64，暫時不樹化，而是進(jìn)行擴容.
//否則才會真正的樹化 -> 剪枝
final void treeifyBin(Node
int n, index; Node
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
}
*/
}
}
EntrySet & KeySet & Values : 均為了更方便的遍歷Map集合 EntrySet： KeySet： Values：
Map接口實現(xiàn)類-HashMap小結(jié)： 1）Map接口的常用實現(xiàn)類：HashMap、Hashtable和Properties 2）HashMap是Map接口使用頻率最高的實現(xiàn)類 3）HashMap是以key-val對兒的方式來村存儲數(shù)據(jù)（HashMap$Node類型） 4）key不能重復(fù)，但是值可以重復(fù)，允許使用null鍵和null值 5）如果添加相同的key，則會覆蓋原來的key-val，等同于修改（即key不會替換，val會替換） 6）與HashSet一樣，不保證映射的順序，因為底層是以hash表的方式來存儲 7）HashMap沒有實現(xiàn)同步，因此是線程不安全的，方法沒有做同步互斥的操作，沒有synchronized
2、LinkedHashMap
???????????詳情看 LinkedHashSet
3、Hashtable
基本介紹 1）存放的元素是鍵值對：即 K-V 2）Hashtable的鍵和值都不能為null，否則會拋出NullPointerException 3）Hashtable 使用方法基本上和HashMap一樣 4）Hashtable 是線程安全的（synchronized），HashMap是線程不安全的源碼剖析
import java.util.Hashtable;
@SuppressWarnings({"all"})
public class HashTableExercise {
public static void main(String[] args) {
Hashtable table = new Hashtable();//ok
// table.put("john", 100); //ok
// //table.put(null, 100); //異常 NullPointerException
// //table.put("john", null);//異常 NullPointerException
// table.put("lucy", 100);//ok
// table.put("lic", 100);//ok
// table.put("lic", 88);//替換
// table.put("hello1", 1);
// table.put("hello2", 1);
// table.put("hello3", 1);
// table.put("hello4", 1);
// table.put("hello5", 1);
// table.put("hello6", 1);
// System.out.println(table);
table.put(null, "a");
//簡單說明一下Hashtable的底層
//1. 底層有數(shù)組 Hashtable$Entry[] 初始化大小為 11
//2. 臨界值 threshold 8 = 11 * 0.75
//3. 擴容: 按照自己的擴容機制來進(jìn)行即可.
//4. 執(zhí)行 方法 addEntry(hash, key, value, index); 添加K-V 封裝到Entry
//5. 當(dāng) if (count >= threshold) 滿足時，就進(jìn)行擴容
//5. 按照 int newCapacity = (oldCapacity << 1) + 1; 的大小擴容.
/*
源碼：
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException(); // 值為空，拋異常
}
// Makes sure the key is not already in the hashtable.
Entry tab[] = table;
int hash = key.hashCode(); // 鍵為空，拋異常
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
*/
}
}
HashMap 和 Hashtable對比
4、Properties
基本介紹 1.Properties類繼承自Hashtable類并且實現(xiàn)了Map接口，也是使用鍵值對兒的形式來保存數(shù)據(jù) 2.它的使用特點和Hashtable類似 3.Properties 更多用于 從xxx.properties文件中，加載數(shù)據(jù)到Properties類對象，并進(jìn)行讀取和修改【說明：xxx.properties文件通常作為配置文件】
示例代碼：
import java.util.Properties;
@SuppressWarnings({"all"})
public class Properties_ {
public static void main(String[] args) {
//老韓解讀
//1. Properties 繼承 Hashtable
//2. 可以通過 k-v 存放數(shù)據(jù)，當(dāng)然key 和 value 不能為 null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//拋出 空指針異常
//properties.put("abc", null); //拋出 空指針異常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的key ， value被替換
System.out.println("properties=" + properties);
//通過k 獲取對應(yīng)值
System.out.println(properties.get("lic"));//88
//刪除
properties.remove("lic");
System.out.println("properties=" + properties);
//修改
properties.put("john", "約翰");
System.out.println("properties=" + properties);
}
}
5、TreeMap
底層：紅黑樹構(gòu)造器 1）無參：保證其key為實現(xiàn)了Comparable接口的類 源碼：“Comparable k = (Comparable) key;” 2）有參：需傳入一個實現(xiàn)了 Comparator 接口的匿名內(nèi)部類(對象)
示例代碼：
import java.util.Comparator;
import java.util.TreeMap;
@SuppressWarnings({"all"})
public class TreeMap_ {
public static void main(String[] args) {
//使用默認(rèn)的構(gòu)造器創(chuàng)建的TreeMap, 是按照key值默認(rèn)的排序規(guī)則進(jìn)行排序的
/*
老韓要求：按照傳入的 k(String) 的大小進(jìn)行排序
*/
// TreeMap treeMap = new TreeMap();
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//按照傳入的 k(String) 的大小進(jìn)行排序
//按照K(String) 的長度大小排序
//return ((String) o2).compareTo((String) o1);
return ((String) o2).length() - ((String) o1).length();
}
});
treeMap.put("jack", "杰克");
treeMap.put("tom", "湯姆");
treeMap.put("kristina", "克瑞斯提諾");
treeMap.put("smith", "斯密斯");
treeMap.put("hsp", "韓順平");//加入不了
System.out.println("treemap=" + treeMap);
/*
老韓解讀源碼：
1. 構(gòu)造器. 把傳入的實現(xiàn)了 Comparator 接口的匿名內(nèi)部類(對象)，傳給 TreeMap 的 comparator 屬性
public TreeMap(Comparator comparator) {
this.comparator = comparator;
}
2. 調(diào)用put方法
2.1 第一次添加, 把k-v 封裝到 Entry對象，放入root
Entry
if (t == null) {
compare(key, key); // type (and possibly null) check
// 【為了檢測第一次加入的key值是否為null，若為null，則會在執(zhí)行compare方法時拋出空指針異常】
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
2.2 以后添加
Comparator cpr = comparator;
if (cpr != null) {
do { //遍歷所有的key , 給當(dāng)前key找到適當(dāng)位置
parent = t;
cmp = cpr.compare(key, t.key);//動態(tài)綁定到我們的匿名內(nèi)部類的compare
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else //如果遍歷過程中，發(fā)現(xiàn)準(zhǔn)備添加Key 和當(dāng)前已有的Key 相等，就不添加
return t.setValue(value);
} while (t != null);
}
*/
}
}
TreeMap 鍵不能為null，但是值可以為null
總結(jié)： 開發(fā)中如何選擇集合實現(xiàn)類 在開發(fā)中，選擇什么集合實現(xiàn)類，主要取決于 業(yè)務(wù)操作特點 ，然后根據(jù)集合實現(xiàn)類特性進(jìn)行選擇，分析如下： 1）先判斷存儲的類型（一組對象[單列]或一組鍵值對[雙列]） 2）一組對象[單列]：Collection接口 ? ? ? ?允許重復(fù)：List ? ? ? ?? ? ? ?增刪多：LinkedList[底層維護(hù)了一個雙向鏈表] ? ? ? ?? ? ? ?改查多：ArrayList[底層維護(hù)Object類型的可變數(shù)組] ? ? ? ?不允許重復(fù)：Set ? ? ? ?? ? ? ?無序：HashSet [ 底層是HashMap，維護(hù)了一個哈希表 即（數(shù)組+鏈表+紅黑樹）] ? ? ? ?? ? ? ?排序：TreeSet ? ? ? ?? ? ? ?插入和取出順序一致：LinkedHashSet，維護(hù)數(shù)組+雙向鏈表 3）一組鍵值對[雙列]：Map ? ? ? ?鍵無序：HashMap [ 底層是哈希表 即（數(shù)組+鏈表+紅黑樹）] ? ? ? ?鍵排序：TreeMap ? ? ? ?鍵插入和取出順序一致：LinkedHashMap ? ? ? ?讀取文件：Properties
三、Collections-Collection的幫助類
介紹 1）Coolections 是一個操作Set、List 和 Map 等集合的工具類 2）Coolections 中提供了一系列靜態(tài)的方法對集合元素進(jìn)行排序、查詢和修改等操作排序操作：（均為static方法） 1）reverse（List）：反轉(zhuǎn) List 中元素的順序 2）shuffle（List）：對 List 集合元素進(jìn)行隨機排序 3）sort（List）：根據(jù)元素的自然順序?qū)χ付?List 集合元素按升序排序 4）sort（List，Comparator）：根據(jù)指定的 Comparator 產(chǎn)生的順序?qū)?List 集合元素進(jìn)行排序 5）swap（List，int，int）：將指定 List 集合中的 i 處元素和 j 處元素進(jìn)行交換查找、替換 1）Object max（Collection）：根據(jù)元素的自然排序，返回給定集合中的最大元素 2）Object max（Collection，Comparator）：根據(jù) Comparator 指定的順序，返回給定集合中的最大元素 3）Object min（Collection） 4）Object min（Collection，Comparator） 5）int frequency（Collection，Object）：返回指定集合中指定元素的出現(xiàn)次數(shù) 6）void copy（List dest，List src）：將src中的內(nèi)容復(fù)制到dest中 7）boolean replaceAll（List list，Object oldVal，Object newVal）：使用新值替換 List 對象的所有舊值
示例代碼：
import java.util.*;
@SuppressWarnings({"all"})
public class Collections_ {
public static void main(String[] args) {
//創(chuàng)建ArrayList 集合，用于測試.
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");
list.add("tom");
// reverse(List)：反轉(zhuǎn) List 中元素的順序
Collections.reverse(list);
System.out.println("list=" + list);
// shuffle(List)：對 List 集合元素進(jìn)行隨機排序
// for (int i = 0; i < 5; i++) {
// Collections.shuffle(list);
// System.out.println("list=" + list);
// }
// sort(List)：根據(jù)元素的自然順序?qū)χ付?List 集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序后");
System.out.println("list=" + list);
// sort(List，Comparator)：根據(jù)指定的 Comparator 產(chǎn)生的順序?qū)?List 集合元素進(jìn)行排序
//我們希望按照 字符串的長度大小排序
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//可以加入校驗代碼.
return ((String) o2).length() - ((String) o1).length();
}
});
System.out.println("字符串長度大小排序=" + list);
// swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進(jìn)行交換
//比如
Collections.swap(list, 0, 1);
System.out.println("交換后的情況");
System.out.println("list=" + list);
//Object max(Collection)：根據(jù)元素的自然順序，返回給定集合中的最大元素
System.out.println("自然順序最大元素=" + Collections.max(list));
//Object max(Collection，Comparator)：根據(jù) Comparator 指定的順序，返回給定集合中的最大元素
//比如，我們要返回長度最大的元素
Object maxObject = Collections.max(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
});
System.out.println("長度最大的元素=" + maxObject);
//Object min(Collection)
//Object min(Collection，Comparator)
//上面的兩個方法，參考max即可
//int frequency(Collection，Object)：返回指定集合中指定元素的出現(xiàn)次數(shù)
System.out.println("tom出現(xiàn)的次數(shù)=" + Collections.frequency(list, "tom"));
//void copy(List dest,List src)：將src中的內(nèi)容復(fù)制到dest中
ArrayList dest = new ArrayList();
//為了完成一個完整拷貝，我們需要先給dest 賦值，大小和list.size()一樣即可
for(int i = 0; i < list.size(); i++) {
dest.add("");
}
//拷貝
Collections.copy(dest, list);
System.out.println("dest=" + dest);
/*
ArrayList dest = new ArrayList();
//為了完成一個完整拷貝，我們需要先給dest 賦值，大小和list.size()一樣即可
for(int i = 0; i < list.size(); i++) {
dest.add("");
}
無法替換成
ArrayList dest = new ArrayList(list.size());
因為只有在調(diào)用add方法時才會改變size的值，使用指定大小的構(gòu)造器只會初始elementData容量為指定大小而不會改變size的值；
即，size的值在這里指的是當(dāng)前實際存入了幾個數(shù)據(jù)，而copy方法底層判斷是否可以進(jìn)行拷貝比較的是原集合和目標(biāo)集合的size，故只能先為dest進(jìn)行賦值才能調(diào)用copy
*/
//boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替換 List 對象的所有舊值
//如果list中，有tom 就替換成 湯姆
Collections.replaceAll(list, "tom", "湯姆");
System.out.println("list替換后=" + list);
}
}
四、Arrays-數(shù)組的幫助類
排序
package com.hspedu.arrays_;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author 韓順平
* @version 1.0
*/
public class ArraysMethod01 {
public static void main(String[] args) {
Integer[] integers = {1, 20, 90};
//遍歷數(shù)組
// for(int i = 0; i < integers.length; i++) {
// System.out.println(integers[i]);
// }
//直接使用Arrays.toString方法，顯示數(shù)組
// System.out.println(Arrays.toString(integers));//
//演示 sort方法的使用
Integer arr[] = {1, -1, 7, 0, 89};
//進(jìn)行排序
//老韓解讀
//1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
//2. 因為數(shù)組是引用類型，所以通過sort排序后，會直接影響到 實參 arr
//3. sort重載的，也可以通過傳入一個接口 Comparator 實現(xiàn)定制排序
//4. 調(diào)用 定制排序 時，傳入兩個參數(shù) (1) 排序的數(shù)組 arr
// (2) 實現(xiàn)了Comparator接口的匿名內(nèi)部類 , 要求實現(xiàn) compare方法
//5. 先演示效果，再解釋
//6. 這里體現(xiàn)了接口編程的方式 , 看看源碼，就明白
// 源碼分析
//(1) Arrays.sort(arr, new Comparator()
//(2) 最終到 TimSort類的 private static
// Comparator c)()
//(3) 執(zhí)行到 binarySort方法的代碼, 會根據(jù)動態(tài)綁定機制 c.compare()執(zhí)行我們傳入的
// 匿名內(nèi)部類的 compare ()
// while (left < right) {
// int mid = (left + right) >>> 1;
// if (c.compare(pivot, a[mid]) < 0)
// right = mid;
// else
// left = mid + 1;
// }
//(4) new Comparator() {
// @Override
// public int compare(Object o1, Object o2) {
// Integer i1 = (Integer) o1;
// Integer i2 = (Integer) o2;
// return i2 - i1;
// }
// }
//(5) public int compare(Object o1, Object o2) 返回的值>0 還是 <0
// 會影響整個排序結(jié)果
// 這就充分體現(xiàn)了 接口編程+動態(tài)綁定+匿名內(nèi)部類的綜合使用->非常靈活
// 將來的底層框架和源碼的使用方式，會非常常見
//Arrays.sort(arr); // 默認(rèn)排序方法
//定制排序
// compare方法返回正數(shù)時會交換兩個對象的位置，即前減后就是升序排列；而后減前就是降序排列
Arrays.sort(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
return i2 - i1;
}
});
System.out.println("===排序后===");
System.out.println(Arrays.toString(arr));//
}
}
模擬Arrays.sort()底層調(diào)用重寫的Comparator接口的compare()進(jìn)行排序的過程
package com.hspedu.arrays_;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author 韓順平
* @version 1.0
*/
public class ArraysSortCustom {
public static void main(String[] args) {
int[] arr = {1, -1, 8, 0, 20};
bubble02(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int i1 = (Integer) o1;
int i2 = (Integer) o2;
return i2 - i1;// return i2 - i1;
}
});
System.out.println("==定制排序后的情況==");
System.out.println(Arrays.toString(arr));
}
//結(jié)合冒泡 + 定制
public static void bubble02(int[] arr, Comparator c) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
//數(shù)組排序由 c.compare(arr[j], arr[j + 1])返回的值決定
if (c.compare(arr[j], arr[j + 1]) > 0) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
查找
package com.hspedu.arrays_;
import java.util.Arrays;
import java.util.List;
/**
* @author 韓順平
* @version 1.0
*/
public class ArraysMethod02 {
public static void main(String[] args) {
Integer[] arr = {1, 2, 90, 123, 567};
// binarySearch 通過二分搜索法進(jìn)行查找，要求必須排好
// 老韓解讀
//1. 使用 binarySearch 二叉查找，下標(biāo)從0開始
//2. 要求該數(shù)組是有序的. 如果該數(shù)組是無序的，不能使用binarySearch
//3. 如果數(shù)組中不存在該元素，就返回 return -(low + 1); // key not found. // low指的是該元素若存在于數(shù)組所在的下標(biāo)位置
int index = Arrays.binarySearch(arr, 567);
int index1 = Arrays.binarySearch(arr, 213); //返回 -5
System.out.println("index=" + index);
}
}
其他方法（copyof、fill、equals、asList）
package com.hspedu.arrays_;
import java.util.Arrays;
import java.util.List;
/**
* @author 韓順平
* @version 1.0
*/
public class ArraysMethod02 {
public static void main(String[] args) {
Integer[] arr = {1, 2, 90, 123, 567};
//copyOf 數(shù)組元素的復(fù)制
// 老韓解讀
//1. 從 arr 數(shù)組中，拷貝 arr.length個元素到 newArr數(shù)組中
//2. 如果拷貝的長度 > arr.length 就在新數(shù)組的后面 增加 null
//3. 如果拷貝長度 < 0 就拋出異常NegativeArraySizeException（負(fù)的數(shù)組大小異常）
//4. 該方法的底層使用的是 System.arraycopy()
Integer[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("==拷貝執(zhí)行完畢后==");
System.out.println(Arrays.toString(newArr));
//fill 數(shù)組元素的填充
Integer[] num = new Integer[]{9,3,2};
//老韓解讀
//1. 使用 99 去填充 num數(shù)組，可以理解成是替換原來的元素
Arrays.fill(num, 99);
System.out.println("==num數(shù)組填充后==");
System.out.println(Arrays.toString(num));
//equals 比較兩個數(shù)組元素內(nèi)容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//老韓解讀
//1. 如果 arr數(shù)組 和 arr2數(shù)組 中的元素完全一樣（包括順序），則返回true;
//2. 如果不是完全一樣，就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 將一組值，轉(zhuǎn)換成list
//老韓解讀
//1. asList方法，會將 (2,3,4,5,6,1)數(shù)據(jù)轉(zhuǎn)成一個List集合
//2. 返回的 asList 編譯類型是 List(接口)
//3. asList 運行類型是 java.util.Arrays$ArrayList, 是Arrays類的靜態(tài)內(nèi)部類：
// private static class ArrayList
// implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList=" + asList);
System.out.println("asList的運行類型" + asList.getClass());
}
}
柚子快報激活碼778899分享：Java 常用類（集合類）
好文推薦
本文內(nèi)容根據(jù)網(wǎng)絡(luò)資料整理，出于傳遞更多信息之目的，不代表金鑰匙跨境贊同其觀點和立場。
轉(zhuǎn)載請注明，如有侵權(quán)，聯(lián)系刪除。
速賣通全球速航
