學(xué)習(xí)目標(biāo)

• 掌握集合框架體系結(jié)構(gòu)
• 掌握List接口存儲(chǔ)特點(diǎn)
• 掌握ArrayList類(lèi)常用方法
• 了解泛型的定義和作用
• 掌握使用集合時(shí)使用泛型來(lái)約束元素類(lèi)型

一、集合框架體系

思考：既然數(shù)組可以存儲(chǔ)多個(gè)數(shù)據(jù)，為什么要出現(xiàn)集合？

• 數(shù)組的長(zhǎng)度是固定的，集合的長(zhǎng)度是可變的。
• 使用Java類(lèi)封裝出一個(gè)個(gè)容器類(lèi)，開(kāi)發(fā)者只需要直接調(diào)用即可，不用再手動(dòng)創(chuàng)建容器類(lèi)。

1.1、集合框架概述

集合是Java中提供的一種容器，可以用來(lái)存儲(chǔ)多個(gè)數(shù)據(jù)，根據(jù)不同存儲(chǔ)方式形成的體系結(jié)構(gòu)，就叫做集合框架體系（掌握）。集合也時(shí)常被稱(chēng)為容器。

List、Set集合是繼承了Colection接口，跟Collection是繼承關(guān)系

而ArrayList、LinkedList跟List是繼承關(guān)系，HashSet、TreeSet跟Set也是繼承關(guān)系，HashMap、TreeMap跟Map也是繼承關(guān)系

• Collection接口：泛指廣義上集合，主要表示List和Set兩種存儲(chǔ)方式。
• List接口：表示列表，規(guī)定了允許記錄添加順序，允許元素重復(fù)的規(guī)范。
• Set接口：表示狹義上集合，規(guī)定了不記錄添加順序，不允許元素重復(fù)的規(guī)范。
• Map接口：表示映射關(guān)系，規(guī)定了兩個(gè)集合映射關(guān)系的規(guī)范。

1.2、集合的分類(lèi)

根據(jù)容器的存儲(chǔ)特點(diǎn)的不同，可以分成三種情況：

• List(列表)：允許記錄添加順序，允許元素重復(fù)。=> 元素有序且可重復(fù)
• Set(數(shù)據(jù)集)：不記錄添加順序，不允許元素重復(fù)。=> 元素?zé)o序且唯一

二、List接口

List接口是Collection接口子接口，List接口定義了一種規(guī)范，要求該容器允許記錄元素的添加順序，也允許元素重復(fù)。那么List接口的實(shí)現(xiàn)類(lèi)都會(huì)遵循這一種規(guī)范。

List集合存儲(chǔ)特點(diǎn)：

• 允許元素重復(fù)
• 允許記錄元素的添加先后順序

該接口常用的實(shí)現(xiàn)類(lèi)有：

• ArrayList類(lèi)：數(shù)組列表，表示數(shù)組結(jié)構(gòu)，底層采用數(shù)組實(shí)現(xiàn)，開(kāi)發(fā)中使用對(duì)多的實(shí)現(xiàn)類(lèi)，重點(diǎn)。
• LinkedList類(lèi)：鏈表，表示雙向列表和雙向隊(duì)列結(jié)構(gòu)，采用鏈表實(shí)現(xiàn)，使用不多。
• Stack類(lèi)：棧，表示棧結(jié)構(gòu)，采用數(shù)組實(shí)現(xiàn)，使用不多。
• Vector類(lèi)：向量，其實(shí)就是古老的ArrayList，采用數(shù)組實(shí)現(xiàn)，使用不多。

一般來(lái)說(shuō)，集合接口的實(shí)現(xiàn)類(lèi)命名規(guī)則：（底層數(shù)據(jù)結(jié)構(gòu) + 接口名）例如：ArrayList

2.1、ArrayList類(lèi)

ArrayList類(lèi)，基于數(shù)組算法的列表，通過(guò)查看源代碼會(huì)發(fā)現(xiàn)底層其實(shí)就是一個(gè)Object數(shù)組。

ArrayList常用方法的API：

public class ArrayListDemo1 {
	public static void main(String[] args) {
		// 創(chuàng)建一個(gè)默認(rèn)長(zhǎng)度的列表對(duì)象
		List list = new ArrayList();
		// 打印集合中元素的個(gè)數(shù)
		System.out.println("元素?cái)?shù)量："+list.size());//0
		// 添加操作：向列表中添加4個(gè)元素
		list.add("Will");
		list.add(100);
		list.add(true);
		list.add("Lucy");
		// 查詢(xún)操作:
		System.out.println("列表中所有元素："+list);//輸出:[Will, 100, true, Lucy]
		System.out.println("元素?cái)?shù)量："+list.size());//4
		System.out.println("第一個(gè)元素："+list.get(0));//Will
		
		// 修改操作：把索引為2的元素，替換為wolfcode
		list.set(2, "wolfcode");
		System.out.println("修改后："+list);//輸出:[Will, 100, wolfcode, Lucy]
		
		// 刪除操作：刪除索引為1的元素
		list.remove(1);
		System.out.println("刪除后："+list);//輸出:[Will, wolfcode, Lucy]
	}
}

2.2、LinkedList類(lèi)

LinkedList類(lèi)，底層采用鏈表算法，實(shí)現(xiàn)了鏈表，隊(duì)列，棧的數(shù)據(jù)結(jié)構(gòu)。無(wú)論是鏈表還是隊(duì)列主要操作的都是頭和尾的元素，因此在LinkedList類(lèi)中除了List接口的方法，還有很多操作頭尾的方法。

LinkedList常用方法的API：

其余方法：

• boolean offerFirst(Object e) 在此列表的開(kāi)頭插入指定的元素。
• boolean offerLast(Object e) 在此列表末尾插入指定的元素。
• Object peekFirst() 獲取但不移除此列表的第一個(gè)元素；如果此列表為空，則返回 null。
• Object peekLast() 獲取但不移除此列表的最后一個(gè)元素；如果此列表為空，則返回 null。
• Object pollFirst() 獲取并移除此列表的第一個(gè)元素；如果此列表為空，則返回 null。
• Object pollLast() 獲取并移除此列表的最后一個(gè)元素；如果此列表為空，則返回 null。
• void push(Object e) 將元素推入此列表所表示的棧。
• Object pop() 從此列表所表示的棧處彈出一個(gè)元素。
• Object peek() 獲取但不移除此列表的頭（第一個(gè)元素）。

LinkedList之所以有這么多方法，是因?yàn)樽陨韺?shí)現(xiàn)了多種數(shù)據(jù)結(jié)構(gòu)，而不同的數(shù)據(jù)結(jié)構(gòu)的操作方法名稱(chēng)不同，在開(kāi)發(fā)中LinkedList使用不是很多，知道存儲(chǔ)特點(diǎn)就可以了。

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		//添加元素
		list.addFirst("A");
		list.addFirst("B");
		System.out.println(list);
		list.addFirst("C");
		System.out.println(list);
		list.addLast("D");
		System.out.println(list);
		//獲取元素
		System.out.println("獲取第一個(gè)元素：" + list.getFirst());//C
		System.out.println("獲取最后一個(gè)元素：" + list.getLast());//D
		//刪除元素
		list.removeFirst();
		System.out.println("刪除第一個(gè)元素后：" + list);//[B, A, D]
		list.removeLast();
		System.out.println("刪除最后一個(gè)元素后：" + list);//[B, A]
	}
}

運(yùn)行結(jié)果

[B, A]
[C, B, A]
[C, B, A, D]
獲取第一個(gè)元素：C
獲取最后一個(gè)元素：D
刪除第一個(gè)元素后：[B, A, D]
刪除最后一個(gè)元素后：[B, A]

三、泛型

3.1、什么是泛型

其實(shí)就是一種類(lèi)型參數(shù)，主要用于某個(gè)類(lèi)或接口中數(shù)據(jù)類(lèi)型不確定時(shí)，可以使用一個(gè)標(biāo)識(shí)符來(lái)表示未知的數(shù)據(jù)類(lèi)型，然后在使用該類(lèi)或接口時(shí)指定該未知類(lèi)型的真實(shí)類(lèi)型。

泛型可用到的接口、類(lèi)、方法中，將數(shù)據(jù)類(lèi)型作為參數(shù)傳遞，其實(shí)更像是一個(gè)數(shù)據(jù)類(lèi)型模板。

如果不使用泛型，從容器中獲取出元素，需要做類(lèi)型強(qiáng)轉(zhuǎn)，也不能限制容器只能存儲(chǔ)相同類(lèi)型的元素。

List list = new ArrayList();
list.add("A");
list.add("B");
String ele = (String) list.get(0);

3.2、自定義和使用泛型

定義泛型：使用一個(gè)標(biāo)識(shí)符，比如T在類(lèi)中表示一種未知的數(shù)據(jù)類(lèi)型。

使用泛型：一般在創(chuàng)建對(duì)象時(shí)，給未知的類(lèi)型設(shè)置一個(gè)具體的類(lèi)型，當(dāng)沒(méi)有指定泛型時(shí)，默認(rèn)類(lèi)型為Object類(lèi)型。

需求：定義一個(gè)類(lèi)Point，x和y表示橫縱坐標(biāo)，分別使用String、Integer、Double表示坐標(biāo)類(lèi)型。

如果沒(méi)有泛型需要設(shè)計(jì)三個(gè)類(lèi)，如下：

定義泛型：

在類(lèi)上聲明使用符號(hào)T,表示未知的類(lèi)型

//在類(lèi)上聲明使用符號(hào)T,表示未知的類(lèi)型
public class Point<T> {
	private T x;
	private T y;
     //省略getter/setter
}

使用泛型：

//沒(méi)有使用泛型，默認(rèn)類(lèi)型是Object
Point p1 = new Point();
Object x1 = p1.getX();
//使用String作為泛型類(lèi)型
Point<String> p2 = new Point<String>();
String x2 = p2.getX();
//使用Integer作為泛型類(lèi)型
Point<Integer> p3 = new Point<Integer>();
Integer x3 = p3.getX();

注意：這里僅僅是演示泛型類(lèi)是怎么回事，并不是要求定義類(lèi)都要使用泛型。

3.3、在集合中使用泛型

拿List接口和ArrayList類(lèi)舉例。

class ArrayList<E>{ 
	public boolean add(E e){
	
	}
	public E get(int index){  
	
	}
}

此時(shí)的E也僅僅是一個(gè)占位符，表示元素（Element）的類(lèi)型，那么當(dāng)使用容器時(shí)給出泛型就表示該容器只能存儲(chǔ)某種類(lèi)型的數(shù)據(jù)。

//只能存儲(chǔ)String類(lèi)型的集合
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");

//只能存儲(chǔ)Integer類(lèi)型的集合
List<Integer> list2 = new ArrayList<Integer>();
list2.add(11);
list2.add(22);

因?yàn)榍昂髢蓚€(gè)泛型類(lèi)型相同（也必須相同），泛型類(lèi)型推斷：

List<String> list1 = new ArrayList<String>();
// 可以簡(jiǎn)寫(xiě)為
List<String> list1 = new ArrayList<>();

通過(guò)反編譯工具，會(huì)發(fā)現(xiàn)泛型其實(shí)是語(yǔ)法糖，也就是說(shuō)編譯之后，泛型就不存在了。

注意：泛型必須是引用類(lèi)型，不能是基本數(shù)據(jù)類(lèi)型（錯(cuò)誤如下）：

List<int> list = new ArrayList<int>();//編譯錯(cuò)誤

泛型不存在繼承的關(guān)系（錯(cuò)誤如下）：

List<Object> list = new ArrayList<String>();	//錯(cuò)誤的

四、集合遍歷

4.1、集合元素遍歷

對(duì)集合中的每一個(gè)元素獲取出來(lái)。

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蟬");
list.add("楊玉環(huán)");

使用for遍歷

for (int index = 0; index < list.size(); index++) {
	String ele = list.get(index);
	System.out.println(ele);
}

使用迭代器遍歷

Iterator表示迭代器對(duì)象，迭代器中擁有一個(gè)指針，默認(rèn)指向第一個(gè)元素之前，

• boolean hasNext()：判斷指針后是否存在下一個(gè)元素
• Object next()：獲取指針位置下一個(gè)元素，獲取后指針向后移動(dòng)一位

Iterator<String&ggt; it = list.iterator();
while(it.hasNext()) {
	String ele = it.next();
	System.out.println(ele);
}

操作原理如下圖：

注意： 此時(shí)，就不能使用兩次迭代器，因?yàn)榈谝粋€(gè)迭代器就已經(jīng)將指針指向了最后一個(gè)元素，這樣的話(huà)第二個(gè)迭代器開(kāi)始的指針一直都是最后一個(gè)

使用for-each遍歷（推薦使用）

for (String ele : list) {
	System.out.println(ele);
}

通過(guò)反編譯工具會(huì)發(fā)現(xiàn)，for-each操作集合時(shí)，其實(shí)底層依然是Iterator，我們直接使用for-each即可。

4.2、并發(fā)修改異常

需求：在迭代集合時(shí)刪除集合元素，比如刪除王昭君。

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蟬");
list.add("楊玉環(huán)");

System.out.println(list);
for (String ele : list) {
	if("王昭君".equals(ele)) {
		list.remove(ele);
	}
}
System.out.println(list);

此時(shí)報(bào)錯(cuò)java.util.ConcurrentModificationException，并發(fā)修改異常。

造成該錯(cuò)誤的原因是，不允許在迭代過(guò)程中改變集合的長(zhǎng)度（不能刪除和增加）。如果要在迭代過(guò)程中刪除元素，就不能使用集合的remove方法，只能使用迭代器的remove方法，此時(shí)只能使用迭代器來(lái)操作，不能使用foreach。

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蟬");
list.add("楊玉環(huán)");
System.out.println(list);
//獲取迭代器對(duì)象
Iterator<String> it = list.iterator();
while(it.hasNext()) {
	String ele = it.next();
	if("王昭君".equals(ele)) {
		it.remove();
	}
}
System.out.println(list);

五、Set接口

? Set是Collection子接口，Set接口定義了一種規(guī)范，也就是該容器不記錄元素的添加順序，也不允許元素重復(fù)，那么Set接口的實(shí)現(xiàn)類(lèi)都遵循這一種規(guī)范。

Set集合存儲(chǔ)特點(diǎn)：

• 不允許元素重復(fù)
• 不會(huì)記錄元素的添加先后順序
• Set只包含從Collection繼承的方法，不過(guò)Set無(wú)法記住添加的順序，不允許包含重復(fù)的元素。當(dāng)試圖添加兩個(gè)相同元素進(jìn)Set集合，添加操作失敗，add()方法返回false。

Set接口定義了一種規(guī)范，也就是該容器不記錄元素的添加順序，也不允許元素重復(fù)。

Set接口常用的實(shí)現(xiàn)類(lèi)有：

• HashSet類(lèi)：底層采用哈希表實(shí)現(xiàn)，開(kāi)發(fā)中使用對(duì)多的實(shí)現(xiàn)類(lèi)，重點(diǎn)。
• TreeSet類(lèi)：底層采用紅黑樹(shù)實(shí)現(xiàn)，可以對(duì)集合中元素排序，使用不多。

HashSet和TreeSet的API都是一樣的：

5.1、HashSet類(lèi)

HashSet 是Set接口的實(shí)現(xiàn)類(lèi)，底層數(shù)據(jù)結(jié)構(gòu)是哈希表，集合容器不記錄元素的添加順序，也不允許元素重復(fù)。通常我們也說(shuō)HashSet中的元素是無(wú)序的、唯一的。

public class HashSetDemo {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		//添加操作：向列表中添加4個(gè)元素
		set.add("Will");
		set.add("wolf");
		set.add("code");
		set.add("Lucy");
        
		//查詢(xún)操作:
		System.out.println("集合中所有元素：" + set);//[code, wolf, Will, Lucy]
		System.out.println("元素?cái)?shù)量：" + set.size());//4
		System.out.println("是否存在某個(gè)元素：" + set.contains("code"));//true
		System.out.println("是否存在某個(gè)元素：" + set.contains("code2"));//false
        
		//刪除操作：刪除code元素
		set.remove("code");
		System.out.println("刪除后：" + set);//[wolf, Will, Lucy]
		
        //使用for-each遍歷
		for (String ele : set) {
			System.out.println(ele);
		}
        
		//使用迭代器遍歷
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			Object ele = it.next();
			System.out.println(ele);
		}
	}
}

哈希表工作原理:

HashSet底層采用哈希表實(shí)現(xiàn)，元素對(duì)象的hashCode值決定了在哈希表中的存儲(chǔ)位置。

向HashSet添加元素時(shí)，經(jīng)過(guò)以下過(guò)程：

• step 1 : 首先計(jì)算要添加元素e的hashCode值，根據(jù) y = k( hashCode ) 計(jì)算出元素在哈希表的存儲(chǔ)位置，一般計(jì)算位置的函數(shù)會(huì)選擇 y = hashcode % 9, 這個(gè)函數(shù)稱(chēng)為散列函數(shù)，可見(jiàn)，散列的位置和添加的位置不一致。
• step 2：根據(jù)散列出來(lái)的位置查看哈希表該位置是否有無(wú)元素，如果沒(méi)有元素，直接添加該元素即可。如果有元素，查看e元素和此位置所有元素的是否相等，如果相等，則不添加，如果不相同，在該位置連接e元素即可。

在哈希表中元素對(duì)象的hashCode和equals方法的很重要。

每一個(gè)存儲(chǔ)到哈希表中的對(duì)象，都得覆蓋hashCode和equals方法用來(lái)判斷是否是同一個(gè)對(duì)象，一般的，根據(jù)對(duì)象的字段數(shù)據(jù)比較來(lái)判斷，通常情況下equals為true的時(shí)候hashCode也應(yīng)該相等。

5.2、TreeSet類(lèi)

TreeSet類(lèi)底層才有紅黑樹(shù)算法，會(huì)對(duì)存儲(chǔ)的元素對(duì)象默認(rèn)使用自然排序（從小到大）。

注意：必須保證TreeSet集合中的元素對(duì)象是相同的數(shù)據(jù)類(lèi)型，否則報(bào)錯(cuò)。

public class TreeSetDemo{
	public static void main(String[] args) {
		Set<String> set = new TreeSet<>();
		set.add("wolf");
		set.add("will");
		set.add("sfef");
		set.add("allen");
		System.out.println(set);// [allen, sfef, will, wolf]
	}
}

第一步：插入第一個(gè)節(jié)點(diǎn)，無(wú)須比較，直接作為根節(jié)點(diǎn)。

第二步：插入第二個(gè)節(jié)點(diǎn)，和wolf節(jié)點(diǎn)做比較，較小，往左移動(dòng)。

第三步：插入第三個(gè)節(jié)點(diǎn)，和wolf節(jié)點(diǎn)比較，較小，左移，再和will節(jié)點(diǎn)比較，較小，再左移。

第四步：由于TreeSet是平衡二叉樹(shù)，如果樹(shù)不平衡，會(huì)對(duì)節(jié)點(diǎn)進(jìn)行調(diào)整。

第五步：插入第四個(gè)節(jié)點(diǎn)，此時(shí)和will節(jié)點(diǎn)作比較，較小，左移，再和stef節(jié)點(diǎn)做比較，較小，左移。

六、Map接口

6.1、認(rèn)識(shí)Map

Map，翻譯為映射，在數(shù)學(xué)中的解釋為：

設(shè)A、B是兩個(gè)非空集合，如果存在一個(gè)法則f，使得A中的每個(gè)元素a，按法則f，在B中有唯一確定的元素b與之對(duì)應(yīng)，則稱(chēng)f為從A到B的映射，記作f：A→B。

也就是說(shuō)映射表示兩個(gè)集合之間各自元素的一種“對(duì)應(yīng)”的關(guān)系，在面向?qū)ο笾形覀兪褂肕ap來(lái)封裝和表示這種關(guān)系。

從定義和結(jié)構(gòu)圖上，可以看出Map并不是集合，而表示兩個(gè)集合之間的一種關(guān)系，故Map沒(méi)有實(shí)現(xiàn)Collection接口。

在Map中，要求A集合中的每一個(gè)元素都可以在B集合中找到唯一的一個(gè)值與之對(duì)應(yīng)。這句話(huà)可以解讀為一個(gè)A集合元素只能對(duì)應(yīng)一個(gè)B集合元素，也就說(shuō)A集合中的元素是不允許重復(fù)的，B集合中的元素可以重復(fù)，也可不重復(fù)。那么不難推斷出A集合應(yīng)該是一個(gè)Set集合，B集合應(yīng)該是List集合。

我們把A集合中的元素稱(chēng)之為key，把B集合中的元素稱(chēng)之為value。

其實(shí)能看出一個(gè)Map其實(shí)就有多個(gè)key-value（鍵值對(duì)）組成的，每一個(gè)鍵值對(duì)我們使用Entry表示。

不難發(fā)現(xiàn)，一個(gè)Map結(jié)構(gòu)也可以理解為是Entry的集合，即Set。

一般的，我們依然習(xí)慣把Map稱(chēng)之為集合，不過(guò)要區(qū)分下，Set和List是單元素集合，Map是雙元素集合。

• 單元素集合：每次只能存儲(chǔ)一個(gè)元素，比如Set和List。
• 雙元素集合：每次需要存儲(chǔ)兩個(gè)元素（一個(gè)key和一個(gè)value），比如Map。

注意：

• Map接口并沒(méi)有繼承于Collection接口也沒(méi)有繼承于Iterable接口，所以不能直接對(duì)Map使用for-each操作。
• 如果不能理解Map的結(jié)構(gòu)，就直接記住Map每次需要存儲(chǔ)兩個(gè)值，一個(gè)是key，一個(gè)是value，其中value表示存儲(chǔ)的數(shù)據(jù)，而key就是這一個(gè)value的名字。

6.2、Map常用的API

添加操作

• boolean put(Object key,Object value)：存儲(chǔ)一個(gè)鍵值對(duì)到Map中
• boolean putAll(Map m)：把m中的所有鍵值對(duì)添加到當(dāng)前Map中

刪除操作

• Object remove(Object key)：從Map中刪除指定key的鍵值對(duì)，并返回被刪除key對(duì)應(yīng)的value

修改操作

• 無(wú)專(zhuān)門(mén)的方法，可以調(diào)用put方法，存儲(chǔ)相同key，不同value的鍵值對(duì)，可以覆蓋原來(lái)的。

查詢(xún)操作

• int size()：返回當(dāng)前Map中鍵值對(duì)個(gè)數(shù)
• boolean isEmpty()：判斷當(dāng)前Map中鍵值對(duì)個(gè)數(shù)是否為0.
• Object get(Object key)：返回Map中指定key對(duì)應(yīng)的value值，如果不存在該key，返回null
• boolean containsKey(Object key):判斷Map中是否包含指定key
• boolean containsValue(Object value):判斷Map中是否包含指定value
• Set keySet()：返回Map中所有key所組成的Set集合
• Collection values()：返回Map中所有value所組成的Collection集合
• Set entrySet()：返回Map中所有鍵值對(duì)所組成的Set集合

注意，標(biāo)紅的是重度使用的方法。

6.3、HashSet

HashMap底層基于哈希表算法，Map中存儲(chǔ)的key對(duì)象的hashCode值決定了在哈希表中的存儲(chǔ)位置，因?yàn)镸ap中的key是Set，所以不能保證添加的先后順序，也不允許重復(fù)。

HashMap key的底層數(shù)據(jù)結(jié)構(gòu)是哈希表

案例： 統(tǒng)計(jì)一個(gè)字符串中每個(gè)字符出現(xiàn)次數(shù)

public class HashMapDemo2{
	public static void main(String[] args) {
		String str = "ABCDEFABCDEABCDABCABA";
		//把字符串轉(zhuǎn)換為char數(shù)組
		char[] charArray = str.toCharArray();
		//Map的key存儲(chǔ)字符，value存儲(chǔ)出現(xiàn)的次數(shù)
		Map<Character, Integer> map = new HashMap<>();
		//迭代每一個(gè)字符
		for (char ch : charArray) {
			//判斷Map中是否已經(jīng)存儲(chǔ)該字符
			if (map.containsKey(ch)) {
				Integer count = map.get(ch);
				//如果已經(jīng)存儲(chǔ)該字符，則把出現(xiàn)次數(shù)加上1
				map.put(ch, count+1);
			}else {
				//如果沒(méi)有存儲(chǔ)該字符，則把設(shè)置次數(shù)為1
				map.put(ch, 1);
			}
		}
		System.out.println(map); 

	}
}

6.4、TreeMap

TreeMap key底層基于紅黑樹(shù)算法，因?yàn)镸ap中的key是Set，所以不能保證添加的先后順序，也不允許重復(fù)，但是Map中存儲(chǔ)的key會(huì)默認(rèn)使用自然排序（從小到大），和TreeSet一樣，除了可以使用自然排序也可以自定義排序。

需求：測(cè)試HashMap和TreeMap中key的順序

public class App {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("girl4", "楊玉環(huán)");
		map.put("girl2", "王昭君");
		map.put("key1", "西施");
		map.put("key3", "貂蟬");
		System.out.println(map);
		//-------------------------------------------
		map = new TreeMap<>(map);
		System.out.println(map);
	}
}

輸出結(jié)果：

{key1=西施, girl4=楊玉環(huán), key3=貂蟬, girl2=王昭君}

{girl2=王昭君, girl4=楊玉環(huán), key1=西施, key3=貂蟬}

總結(jié)

以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。