Java集合的背景
⒈Java知識中有一個類集框架的概念，每種文獻各有各的說法，也有的叫做Java集合類，造成混亂，
并且概念中Collection翻譯成中文又是類集的意思，Set翻譯成中文是集合的意思，
混亂的翻譯、指代不明的名詞概念以及網路上copy的差錯，導致初學者從入門到放棄，
現在本學習筆記將幫你梳理基礎概念、供你參考解決疑惑，
⒉JDK 1.2版本開始引入類集開發框架，提供一系列介面和實作子類，最初時JDK版本都是使用
Object型別實作資料接收（導致可能會存在ClassCastException拋例外安全隱患），隨技術提高
增加泛型進行規定，才能使演算法有良好的提高
了解Java集合類
?什么是集合？
集合框架：用于存盤資料的容器
1.2集合與陣列的區別
（1）長度區別：集合長度可變，陣列長度不可變
（2）內容區別：集合可存盤不同型別元素，陣列存盤只可單一型別元素
（3）元素區別：集合只能存盤參考型別元素，陣列可存盤參考型別，也可存盤基本型別
-
首先讓我們了解了解Java集合類之間的關系吧
Java各集合類之間的關系①Java集合要從兩大介面說起，一為Collection介面，二為Map介面，都繼承了Iterable介面，它們是同一個層次的， ②Collection介面被List介面和Set介面繼承； ③List介面有三個實作類，ArrayList，LinkedList，Vector； ④Set介面被HashSet類實作，被SortedSet介面繼承，同時TreeSet類實作SortedSet介面，LinkedHashSet類繼承 HashSet類； ⑤Map介面有兩個實作類，HashMap，HashTable，同時Propertise類繼承HashTable； ⑥Map介面被SortedMap介面繼承，同時TreeMap類實作了SortedMap介面；
使用類集框架優點
?使用核心集合類降低開發成本，而非實作我們自己的集合類，易擴展或修改，
?隨著使用經過嚴格測驗的集合框架類，代碼質量會得到提高，
?通過使用JDK附帶的集合類，可以降低代碼維護成本，
?復用性和可操作性，
?允許不同型別的類集以相同的方式和高度互操做方式作業，
對集合類簡單介紹
1. Collection介面（）
㈠Collection介面為單列集合的頂層介面，含有允許常見操作，
//添加方法：
add(Object o) //添加指定元素
addAll(Collection c) //添加指定集合
//洗掉方法：
remove(Object o) //洗掉指定元素
removeAll(Collection c) //輸出兩個集合的交集
retainAll(Collection c) //保留兩個集合的交集
clear() //清空集合
//查詢方法：
size() //集合中的有效元素個數
toArray() //將集合中的元素轉換成Object型別陣列
//判斷方法：
isEmpty() //判斷是否為空
equals(Object o) //判斷是否與指定元素相同
contains(Object o) //判斷是否包含指定元素
containsAll(Collection c) //判斷是否包含指定集合
Collection介面的常用子類
1.1 List集合
? List 子介面的特點：
? 元素可重復性; // List介面的最大特點；
? 有索引，可進行精準的操作某特定元素；
? 元素有序性，存盤及取出的順序一致；
? 可以存多個null；
List介面擴充的方法
List 子介面的定義：public interface List<E> extends Collection<E>
注：get方法比較常用
?List常見的子類
?List和Vector的比較
范例：
import java.util.List;
import java.util.Arrays;
class Solution {
public static void main(String[] args) {
//List<Integer> ls1 = Arrays.asList(1, 2, null);
List<String> ls2 = List.of("JieWen","2","King");
Object result[] = ls2.toArray();//將List轉為Array儲存
//System.out.println(ls1.contains(null));
for(Object temp : result){
System.out.printf(temp + "\");
}
}
}
//結果：JieWen、2、King
1.1.1 ArrayList 子類
?線性結構最方便的實作就是基于陣列實作；
ArrayList的類定義：
public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
你了解這三種構造方法？
public ArrayList() {
this(10);
//呼叫ArrayList(10) 默認初始化一個大小為10的object陣列，
}
public ArrayList(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//如果用戶初始化大小小于0拋例外，否則新建一個用戶初始值大小的object陣列，
this.elementData = new Object[initialCapacity];
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
// 當c.toArray回傳的不是object型別的陣列時，進行下面轉化，
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
/*默認情況下使用ArrayList會生成一個大小為10的Object型別的陣列，
也可以呼叫ArrayList(int initialCapacity) 來初始化Object陣列的大小，
并且用戶可以往ArrayList中傳入一個容器只要這個容器是Collection型別的，
呼叫ArrayList(Collection<? extends E> c)介面的時候會將容器陣列化處理并
將這個陣列值賦給Object陣列，*/
⑴ ArrayList的特點：
?ArrayList 基于索引的，因此可以隨機訪問；
?ArrayList 不太適合洗掉操作，洗掉元素將導致大量的資料移動；
?ArrayList 可以包含重復的元素；
?ArrayList 是非執行緒安全的；
?ArrayList 維護了元素插入時的順序，
⑵ ArrayList的底層分析：
①陣列結構是有序的元素序列，在記憶體中開辟一段連續的空間，在空間中存放元素，每個空間都有編號，
通過編號可以快速找到相應元素，因此查詢快；
②陣列初始化時長度是固定的，查詢快、要想增刪元素，動態開辟空間、必須創建一個新陣列，把源陣列的元素復制進來，隨后源陣列銷毀，耗時長，因此增刪慢，
⑶ArrayList 常見方法：
1.add(E e) 在集合末尾新增一個元素
2.add(int index, E element) 在指定位置添加元素
3.get(int index）獲取指定位置的元素
4.remove(int index) 洗掉指定位置的元素
5.remove(Object o) 洗掉指定元素
6.indexOf(Object o) 查詢指定元素的位置 lastIndexOf也一樣，只是從尾部開始遍歷
7.set(int index, E element) 設定指定位置的元素值
8.retainAll(Collection<?> c) 求兩個集合的交集
⑷ArrayLIst 實作：
import java.util.*;
public class Daycare{
public static void main(String[] args){
//ArrayList Collections.addAll(集合,元素,....)
//創建一個集合物件裝名字
ArrayList<String> list=new ArrayList<>();
//一次添加一個元素的方式：添加：Andy Lee
Collections.addAll(list,"Andy","Lee");
//統計集合里面有幾個人的姓名
System.out.println("人的個數："+list.size());
//列印第一個人的姓名
System.out.println("第一個人的名字："+list.get(0));
//判斷集合里面是否出現Lee的名字
System.out.println(list.contains("Lee"));
//使用兩種不同的方式列印 所有以A開頭的名字
for(String name:list){
if(name.charAt(0)=='A'){
System.out.println(name);
}
}
for(String name:list){
if(name.startsWith("A")){
System.out.println(name);
}
}
//用迭代器
for(Iterator<String> car=list.iterator();car.hasNext();){
String name=car.next();
if(name.startsWith("A")){
System.out.println(name);
}
}
}
}
（5）ArrayList 保存自定義類物件
必須實作的方法：
1、要在自定義類中重寫equals()方法
2、在實際開發之中 remove() 與 contains(Object o)都是很少用的
3、主要用到的還是 add() 方法與 get()方法
4、在重寫equals()方法的時候要判斷3個為空，之后轉型
[1.是否是自己 2.是否為空 3.是否為本類(instanceof判斷)]
方法的實作代碼：
import java.util.ArrayList;
/**
* ArrayList保存自定義類物件
**/
public class ArrayListSaveDefineClassInstance {
public static void main(String[] args) {
ArrayList<ArrayListPerson> all= new ArrayList<ArrayListPerson> ();
all.add(new ArrayListPerson("張三" , 19));
all.add(new ArrayListPerson("李四" , 20));
all.add(new ArrayListPerson("王五" , 12));
//由于地址不一樣，無法找到也無法，洗掉，所以要在自定義類中復寫equals()方法
System.out.println(all.contains(new ArrayListPerson("王五" , 12)));
all.remove(new ArrayListPerson("王五" , 12));
System.out.println(all);
}
}
/**
* 自定義類
**/
class ArrayListPerson{
private String name;
private int age;
//需要覆寫的equals()方法才能保證能夠實作查找
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ArrayListPerson)) {
return false;
}
if (this == obj) {
return false;
}
if (obj == null) {
return false;
}
ArrayListPerson objP = (ArrayListPerson) obj;
return this.name==objP.name && this.age==objP.age;
}
@Override
public String toString() {
return "ArrayListPerson{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public ArrayListPerson(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;
}
}
1.1.2 LinkedList 子類
?概述
LinkedList 是 Java 集合中比較常用的資料結構，與 ArrayList 一樣，實作了 List 介面，
只不過 ArrayList 是基于陣列實作的，而 LinkedList 是基于鏈表實作的，所以 LinkedList
插入和洗掉方面要優于 ArrayList，而隨機訪問上則 ArrayList 性能更好，除了 LIst 介面
之外，LinkedList 還實作了 Deque，Cloneable，Serializable 三個介面，這說明該資料
結構支持佇列，克隆和序列化操作的，與 ArrayList 一樣，允許 null 元素的存在，且是
不支持多執行緒的，
?LinkedList 特點
1.資料結構由雙向鏈表實作
2.它不存在容量不足的問題
3.因為是鏈表無下標，所以查詢慢、但是增刪快，
?構造方法
public LinkedList() {}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
LinkedList 提供了兩個構造方法：LinkedList() 和 LinkedList(Collection<? extends E> c)，
?LinkedList 實作原理：
LinkedList是基于雙向鏈表的資料結構實作的，鏈表是可以占用一段不連續的記憶體，雙向鏈表有前驅節
點和后驅節點，里面存盤的是上一個元素和后一個元素所在的位置，中間的黃色部分就是業務資料了，
當我們需要執行插入的任務，比如第一個元素和第二個元素之間，只需要改變他們的前驅節點和后驅節
點的指向就可以了，不要像動態陣列那么麻煩，洗掉也是同樣的操作，但是因為是不連續的記憶體空間，
當需要執行查找，需要從第一個元素開始查找，直到找到我們需要的資料，
?LinkedList 常用方法：
增加：
add(E e)：在鏈表后添加一個元素； 通用方法
addFirst(E e)：在鏈表頭部插入一個元素； 特有方法
addLast(E e)：在鏈表尾部添加一個元素； 特有方法
push(E e)：與addFirst方法一致
offer(E e)：在鏈表尾部插入一個元素
add(int index, E element)：在指定位置插入一個元素，
offerFirst(E e)：JDK1.6版本之后，在頭部添加； 特有方法
offerLast(E e)：JDK1.6版本之后，在尾部添加； 特有方法
洗掉：
remove() ：移除鏈表中第一個元素; 通用方法
remove(E e)：移除指定元素； 通用方法
removeFirst(E e)：洗掉頭，獲取元素并洗掉； 特有方法
removeLast(E e)：洗掉尾； 特有方法
pollFirst()：洗掉頭； 特有方法
pollLast()：洗掉尾； 特有方法
pop()：和removeFirst方法一致，洗掉頭，
poll()：查詢并移除第一個元素 特有方法
查：
get(int index)：按照下標獲取元素； 通用方法
getFirst()：獲取第一個元素； 特有方法
getLast()：獲取最后一個元素； 特有方法
peek()：獲取第一個元素，但是不移除； 特有方法
peekFirst()：獲取第一個元素，但是不移除；
peekLast()：獲取最后一個元素，但是不移除；
pollFirst()：查詢并洗掉頭； 特有方法
pollLast()：洗掉尾； 特有方法
poll()：查詢并移除第一個元素 特有方法
?LinkedList 的實作方法：
public class LinkedListMethodsDemo {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("first");
linkedList.add("second");
linkedList.add("third");
System.out.println(linkedList);
linkedList.addFirst("addFirst");
System.out.println(linkedList);
linkedList.addLast("addLast");
System.out.println(linkedList);
linkedList.add(2, "addByIndex");
System.out.println(linkedList);
}
}
/*輸出結果：
[first, second, third]
[addFirst, first, second, third]
[addFirst, first, second, third, addLast]
[addFirst, first, addByIndex, second, third, addLast]*/
1.1.3 Vector 子類
注：Vector類在JDK1.0就已經提供，但是由于以下：
1.因為vector是執行緒安全的，所以效率低，這容易理解，類似StringBuffer
2.Vector空間滿了之后，擴容是一倍，而ArrayList僅僅是一半
3.Vector分配記憶體的時候需要連續的存盤空間，如果資料太多，容易分配記憶體失敗
4.只能在尾部進行插入和洗掉操作，效率低
所以vector子類目前已經過時，但是由于其廣泛性并沒有棄用，
?Vector底層分析：
底層資料結構：陣列實作，和ArrayList 一樣，但是Vector 是同步方法執行緒安全，但是效率低，所以不推薦使用，只有要求需要執行緒安全才會去使用該子類；
?Vector 所定義結構
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.Vector<E>
范例：
public class VectorTest{
public static void main(String[] args){
List<String> all = new Vector<String>();
all.add("JieWen");
System.out.printf(all);
}
}
1.2 Set 集合
?提供該介面原因：
為了與List介面的使用有所區分，在進行Set介面設計的時候要求內部不允許保存重復的元素，Set介面定義如下：
public interface Set<E> extends Collection<E>(){}
Set介面的使用
public class SetTest{
public static void main(String[] args){
Set<String> all = new Set.of("JieWen","XiaoFei");
System.out.printf(all);
?Set的特性
A:存入集合的順序和取出集合的順序不一致
B:沒有索引，所以不能使用普通for回圈，可Foreach回圈，
C:存入集合的元素沒有重復（如果重復會拋出例外）特點
? 基本和Collection介面的方法一種，沒有進行功能的擴充，
?Set的子類
Set常用的方法
Set 介面繼承 Collection 介面，而且它不允許集合中存在重復項，所有原始方法都是現成的，
沒有引入新方法，具體的 Set 實作類依賴添加的物件的 equals() 方法來檢查等同性，
1. public int size() ：回傳set中元素的數目，如果set包含的元素數大于Integer.MAX_VALUE，回傳Integer.MAX_VALUE；
2. public boolean isEmpty() ：如果set中不含元素，回傳true ；
3.public boolean contains(Object o) ：如果set包含指定元素，回傳true ；
4.public Iterator iterator()： 回傳set中元素的迭代器，元素回傳沒有特定的順序，除非set提高該保證的某些類的實體 ；
5. public boolean add(Object o) ：如果set中不存在指定元素，則向set加入；
6.public boolean remove(Object o) ：如果set中存在指定元素，則從set中洗掉 ；
7.public boolean removeAll(Collection c) ：如果set包含指定集合，則從set中洗掉指定集合的所有元素 ；
8.public void clear() ：從set中洗掉所有元素；
1.2.1 HashSet實作類
資料結構：
JDK 1.8之前是通過哈希表的單向鏈表和陣列來組成、JDK 1.8之后將單鏈表該為（單鏈表+紅黑樹）目的在于：當鏈表的長度超過閥值（8）時改為紅黑樹、而鏈表查找元素的時間復雜度為 O(n)，遠遠大于紅黑樹的 O(logn)，尤其是在節點越來越多的情況下，O(logn) 體現出的優勢會更加明顯；簡而言之就是為了提升查詢的效率，
■HashSet 的特性：（散列存放）
1.元素的無序性 ！= 隨機性，真正的無序性，是指元素在底層存盤的位置是無序的，
（哈希表通過 hashcode 哈希值和 equals() 方法進行判斷保證獨一性）
2.不可重復性，當向Set集合中添加相同元素的時候，后面的這個添加不進去，程式不會報錯！
3.Set集合沒有自己獨有的方法，它的方法都是繼承于Collection介面中的現有方法
4.HashSet類是非執行緒安全的
5.允許集合元素值為null
■HashSet的構造方法
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable {}
?方法概覽
1.add(Object o)和addAll(Collection c)增加元素
2.contains(Object o)和containsAll(Collection c)判斷元素是否存在
3.isEmpty()判斷集合是否為空
4.remove(Object o)和removeAll(Collection c)洗掉元素
5.size()回傳集合的大小
6.clear()清空集合
7.iterator()迭代器
8.toArray()將內容轉到陣列中
范例：
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class Test {
public static void main(String args[]) {
int[] a= {6,5,4,3,2,1,1,5,6,7};
HashSet<Integer> hs=new HashSet<>(); //所有的集合中存盤的元素的型別都不會是基本資料型別！！！使用菱形推斷創建物件
for(int i:a) {
if(!hs.add(i))
System.out.println(i+"已存在！"); //HashSet中的元素不允許重復！
hs.add(i);
}
/*for(int i=0;i<a.length;i++) {
if(!hs.add(a[i]))
System.out.println(a[i]+"已存在！");
hs.add(a[i]);
}*/
if(!hs.isEmpty()) { //判斷集合是否為空
System.out.println("hs不為空");
}
if(hs.contains(7)) { //判斷集合是否包含元素
System.out.println("集合hs中包括元素7");
}
for(int j : hs) {
System.out.print(j+" ");
}
System.out.println();
HashSet<Integer> h=new HashSet<>();
h.add(102); //添加元素102
//h.remove(102); 洗掉元素102
h.add(103);
h.add(2);
if(hs.containsAll(h)) { //判斷集合是否包含另一集合的所有元素
System.out.println("hs集合中包含h集合中的所有元素");
}
else {
System.out.println("hs集合中不包含h集合中的所有元素");
}
//hs.addAll(h); 將集合h中的所有元素添加到hs中
hs.removeAll(h); //洗掉hs和h的交集中的元素
//hs.retainAll(h); 取得hs和h的交集的元素
//hs.clear(); 洗掉所有hs的元素
Object[] objects=hs.toArray(); //HashSet.toArray()的無參方法
for(Object o:objects) {
System.out.print(o+" ");
}
System.out.println();
Integer[] mid=hs.toArray(new Integer[hs.size()]); //HashSet.toArray()的帶參方法
for(Integer integer:mid) {
System.out.print(integer+" ");
}
System.out.println();
hs.removeAll(java.util.Collections.singleton(7)); //Collections.singleton(7):生成只有一個元素7的集合
Iterator<Integer> iterator=hs.iterator();
while(iterator.hasNext()) {
System.out.print(iterator.next()+" ");
}
System.out.println();
}
}
1.2.2 TreeSet 子類
?資料結構：紅黑樹
?TreeSet特性
1.TreeSet中存盤的型別必須是一致的，不能一下存int，一下又存string
2、TreeSet在遍歷集合元素時，是有順序的【從小到大】（ASCLL碼排序）
3、排序：當向TreeSet中添加自定義物件時，有2種排序方法，1：自然排序 2、定制排序
自然排序：要求自定義類實作java.lang.Comparable介面并重寫compareTo(Object obj)方法，
在此方法中，指明按照自定義類的哪個屬性進行排序
?底層分析
TreeSet的底層是TreeMap，添加的資料存入了map的key的位置，而value則固定是PRESENT，TreeSet中的元素是有序且不重復的，因為TreeMap中的key是有序且不重復的，
注意： 不允許存放null，
范例：
public class TreeTest{
public static void main(String[] srgs){
Set<String> all = new Set<>();
all.add("JieWen");
System.out.printf(all);
}
}
?TreeSet 子類排序分析
?即類要實作Comparable介面，并重寫compareTo()方法，TreeSet物件呼叫add()方法時，會將存入的物件提升為Comparable型別，然后呼叫物件中的compareTo()方法進行比較，判斷有沒有重復元素，根據比較的回傳值進行存盤，
因為TreeSet底層是二叉樹，當compareTo方法回傳0時，不存盤；當compareTo方法回傳正數時，存入二叉樹的右子樹；當compareTo方法回傳負數時，存入二叉樹的左子樹，如果一個類沒有實作Comparable介面就將該類物件存入TreeSet集合，會發生型別轉換例外，
?自然排序
import java.util.Set;
import java.util.TreeSet;
//TreeSet的自然排序
//1.物體類實作Comparable介面,重寫compareTo()方法
public class TestTreeSetSort1 {
public static void main(String[] args) {
Set<Student> tree=new TreeSet();
Student s1=new Student("JieWen",21,88);
Student s2=new Student("Feign",21,34);
Student s3=new Student("K",24,99);
Student s4=new Student("J",27,13);
Student s5=new Student("N",22,65);
tree.add(s1);
tree.add(s2);
tree.add(s3);
tree.add(s4);
tree.add(s5);
//Exception in thread "main" java.lang.ClassCastException: com.qianfeng.kxf.day25.set.Student cannot be cast to java.lang.Comparable
//為什么報錯?因為添加的是物件元素,必須實作一個排序,否則就會型別轉換錯誤的問題
System.out.println("元素物件多少個"+tree.size());
for(Student s:tree) {
System.out.println(s);
}
}
}
class Student implements Comparable{
private String name;
private int age;
private int score;
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
super();
}
/*//重寫該方法:只通過名字進行排序
@Override
public int compareTo(Object o) {
//先轉換為Student型別物件
Student str=(Student)o;
//先對姓名進行排序,直接呼叫String型別中的compareTo()方法進行比較
return this.name.compareTo(str.name);
}
// 元素物件多少個3
// Student [name=J, age=27, score=13]
// Student [name=K, age=24, score=99]
// Student [name=JieWen, age=21, score=88]
*/
/*//如果名字相同,就按年齡排序
public int compareTo(Object o) {
Student stu=(Student)o;
//先對名字排序:升序
int n=this.name.compareTo(stu.name);
//如果名字相同就比較年齡 :升序
return n==0?this.age-stu.age:n;
}*/
//如果名字相同,就按年齡排,如果年齡還相同就按成績排
public int compareTo(Object o) {
Student stu=(Student)o;
int n=this.name.compareTo(stu.name);
int a=n==0?this.age-stu.age:n;
return a==0?this.score-stu.score:a;
}
}
?定制排序
//主要實作方法
class MyComparator implements Comparator<Person>{
//按姓名排序
/*@Override
public int compare(Person o1, Person o2) {
int n=o1.getName().compareTo(o2.getName());
return n;
}*/
//按姓名和年齡排序
/*public int compare(Person p1,Person p2) {
int n=p1.getName().compareTo(p2.getName());
return n==0?p1.getAge()-p2.getAge():n;
}*/
//按姓名.年齡.成績排序
public int compare(Person p1,Person p2) {
int n=p1.getName().compareTo(p2.getName());
int a=n==0?p1.getAge()-p2.getAge():n;
return a==0?p1.getScore()-p2.getScore():a;
}
}
?消除重復元素
由于TreeSet有排序要求，所以利用Comparable介面實作重復元素判斷，而非排序集合
中對重復元素的判斷Object類提供的hash碼，boolean equals()物件比較，
代碼實作
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
People people = (People) o;
return Objects.equals(name, people.name) &&
Objects.equals(age, people.age);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public int compareTo(People o) {
if(this.age > o.age){
return 1;
}else if(this.age < o.age){
return -1;
}else {
return this.name.compareTo(o.name);
}
}
1.2.3 LinkedHashSet 實作類
目的：為了解決HashSet實作類的無序性而創建的一個類，實作基于鏈表的順序儲存
資料結構：和HashSet基本一致，只是將單鏈表改為雙向鏈表
?LinkedHashSet 特性：
>查詢快、元素有序、元素不可重復、沒有索引，
底層分析：
為HashSet的子類，只是比他多添加一條記錄元素順序的鏈表，所以其為有序；
//從鍵盤輸入字串，去掉重復字符輸出
public static void getSingleChar(){
Scanner sc=new Scanner(System.in);
System.out.println("請輸入一串字符：");
String str=sc.nextLine();
char[] ch=str.toCharArray();
LinkedHashSet<Character> linkedHashSet=new LinkedHashSet<>();
for (char c:ch) {
linkedHashSet.add(c);
}
for (Character c:linkedHashSet) {
System.out.println(c);
}
}
1.3 Map 子類
?概述
Map是STL的一個關聯容器，它提供一對一（其中第一個可以稱為關鍵字，每個關鍵字只能在map中出現一次，第二個可能稱為該關鍵字的值）的資料處理能力，由于這個特性，它完成有可能在我們處理一對一資料的時候，在編程上提供快速通道，這里說下map內部資料的組織，map內部自建一顆紅黑樹(一種非嚴格意義上的平衡二叉樹)，這顆樹具有對資料自動排序的功能，所以在map內部所有的資料都是有序的；
（key,value）即鍵值對，key不允許重復，value允許重復，一一對應；
Map屬于雙列集合，保證key唯一，必須重寫hashCode 和equals()方法；
?Map常用方法
添加、洗掉、修改操作：
1.Object put(Object key,Object value)：將指定key-value添加到(或修改)當前map物件中
2.void putAll(Map m):將m中的所有key-value對存放到當前map中
3.Object remove(Object key)：移除指定key的key-value對，并回傳value
4.void clear()：清空當前map中的所有資料
元素查詢的操作：
1.Object get(Object key)：獲取指定key對應的value
2.boolean containsKey(Object key)：是否包含指定的key
3.boolean containsValue(Object value)：是否包含指定的value
4.int size()：回傳map中key-value對的個數
5.boolean isEmpty()：判斷當前map是否為空
6.boolean equals(Object obj)：判斷當前map和引數物件obj是否相等
元視圖操作的方法：
1.Set keySet()：回傳所有key構成的Set集合
2.Collection values()：回傳所有value構成的Collection集合
3.Set entrySet()：回傳所有key-value對構成的Set集合
注：JDK1.9后為了方便進行Map資料的操作，添加了Map.of()的方法接受每一組資料轉為Map；
public class MapTest{
public static void main(String[] srgs){
//one =1,two =2;
Map<String,Integer> map = Map.of("one",1,"two",2);//k,v型
System.out.printf(map);
//{two=2},{one=1}
}
}
注意：
⒈如果設定的key重復，則程式拋出IllegalArgumentException例外，提示key重復；
2.如果設定的key或value為null，則拋出NullPointerException例外；
?Map和Collection之間的區別
↘Collection介面是目的為了設定內容再 輸出
↘Map介面設定完內容再 查找
1.3.1 HashMap 子類
?概述
HashMap 是基于哈希表的 Map 介面的實作，以 Key-Value 的形式存在，即存盤的物件是 Entry (同時包含了 Key 和 Value) ，在HashMap中，其會根據hash演算法來計算key-value的存盤位置并進行快速存取，特別地，HashMap最多只允許一條Entry的鍵為Null(多潭訓覆寫)，但允許多條Entry的值為Null，此外，HashMap 是 Map 的一個非同步的實作，不同步導致可能多個執行緒同時寫該方法；
?資料結構：
JDK1.8 之前哈希表（陣列+單向鏈表）；JDK 1.8之后（陣列+單向鏈表+紅黑樹）；當鏈表長度超過閥值時鏈表轉為紅黑樹；原因和HashSet一致；HashMap的底層構造和HashSet一致；
?HashMap的特性
1、允許key/value為null，但是key只能有一個null
2、非執行緒安全，多個執行緒同時操作同一個HashMap實體所做的修改在執行緒間不同步
3、遍歷時不保證任何順序，跟元素插入順序或者訪問順序無關
4、進行遍歷時如果執行HashMap的remove(Object key)或者put(Object
value)方法時會快速失敗，拋出例外ConcurrentModificationException，遍歷時洗掉元素只能通過Iterator本身的remove()方法實作，
?HashMap常用方法
1.put(Object key,Object value)在此映射中關聯指定的Key-value;
2.putAll(Collection c)在此映射中將指定的映射關系添加到被操作的映射中;
3.get(Object key)根據key獲取指定的value;
4.containsKey(Object key)檢測該映射中是否存在指定key的映射，有則回傳true；沒有則回傳false;
5.containsValue(Object value)檢測該映射中是否存在指定value的映射，有則回傳true；沒有則回傳false;
6.remove(Object key)根據key的值洗掉指定的映射關系;
7.isEmpty()測驗映射是否為空;
8.values()回傳值的集合;
?HashMap方法實作
public class HashMap{
public static void main(){
Map<String,Integer> map = new HashMap<>();
map.put("one",1);
map.put("two",2);
map.put("null",0);
map.put("one",101);//就近原則覆寫前面的
System.out.printf(map.get("ten"));不存在則回傳null；
}
}
?迭代器輸出
Map<String, String> map = new HashMap<>();
Iterator iter = map.entrySet().iterator();//比Set多一步
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
System.out.println("[Key] : " + entry.getKey() + " [Value] : " + entry.getValue());
}
1.3.2 LinkedHashMap 子類
資料結構：
和HashMapt基本一致，只是將單鏈表改為雙向鏈表
?LinkedHashMap 特性：
迭代HashMap的順序并不是HashMap放置的順序，也就是無序，而LinkedHashMap，它雖然增加了時間和空間上的開銷，通過一個雙向鏈表，LinkedHashMap保證了元素迭代的順序，該迭代順序有兩種，可以是插入順序或者是訪問順序，LinkedHashMap繼承了HashMap類，有著HashMap的所有功能，還提供了記住元素添加順序的方法，通過鏈表實作；
key不可重復但是可以為null；value可以重復；
?LinkedHashMap 定義：
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>{}
LinkedHashMap方法實作和上面 HashMap 基本一致，
1.3.3 Hashtable 子類
?概述
早期的字典實作類（通過哈希值查找），可以更方便實作資料查詢；但是這個子類比較古老，目前已經不推薦使用該類，因為該方法是同步方法，執行緒安全但是效率比較低；同時Hashtable不允許儲存null資料，無序；
? Hashtable 的定義
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
該子類的保存資料和Map類一致 ；
注：目前將方法contains()改為以下兩種：–containsValue() 值判斷
--------------------------------------------------------containsKey() 鍵判斷；
1.3.4 TreeMap 子類
?概述
TreeSet是一個有序集合，可以以任意順序將元素插入到集合中，在對集合進行遍歷的時候，每個元素將自動按照排序后的順序呈現，底層使用的是二叉樹(更具體點是紅黑樹)實作，對于元素之間排序，如果不指定自定義的比較器Comparator，那么插入的物件 必須實作Comparable 介面，元素按照實作此介面的compareTo()方法去排序，如果指定了自定義的比較器Comparator，優先使用Comparator去對元素進行排序，比較規則決定了元素是否可以重復，以及元素的排序結果，
** ?資料結構**：紅黑樹
? TreeMap 特性
(1)保存的元素按照一定的規則有序
(2)可自定義排序規則
(3)非執行緒安全
底層分析：和TreeSet的相類似；
?TreeMap 排序方法
public class MapTest{
public static void main(String[] srgs){
//one =1,two =2;
Map<String,Integer> map = new TreeMap<>();//k,v型
map.put("A",1);
map.put("C",3);
map.put("B",2);
System.out.printf(map);
//結果：
//{A=1,B =2,C= 3}//自然排序默認
}
}
自然排序和定制排序和TreeSet一致（因為TreeSet保存的值為Map的鍵Key儲存的值）利用Key值來進行排序；
?hashCode（）與equals（）的相關規定：
如果兩個物件相等，則hashcode一定也是相同的 兩個物件相等,對兩個equals方法回傳true
兩個物件有相同的hashcode值，它們也不一定是相等的 綜上，equals方法被覆寫過，則hashCode方法也必須被覆寫
hashCode()的默認行為是對堆上的物件產生獨特值，如果沒有重寫hashCode()，則該class的兩個物件無論如何都不會相等（即使這兩個物件指向相同的資料），
1.3.5 Map.Entry 內部介面
?概述
在Map類設計是，提供了一個嵌套介面（static修飾的介面）：Entry，Entry將鍵值對的對應關系封裝成了物件，即鍵值對物件，這樣我們在遍歷Map集合時，就可以從每一個鍵值對（Entry）物件中獲取對應的鍵與對應的值，可以獲取相應的值；
范例
public class MapEntryTest{
public static void main(String[] args){
Map.Entry<String,Integer> entry= Map.entry("one",1);
System.out.printf(entry.getKey());//獲取Key
System.out.printf(entry.getValue());//獲取Value
}
}
2.1 Iterator 迭代輸出
?概述
Java集合框架的集合類，我們有時候稱之為容器，容器的種類有很多種，比如ArrayList、LinkedList、HashSet…，每種容器都有自己的特點，ArrayList底層維護的是一個陣列；LinkedList是鏈表結構的；HashSet依賴的是哈希表，每種容器都有自己特有的資料結構，
因為容器的內部結構不同，很多時候可能不知道該怎樣去遍歷一個容器中的元素，所以為了使對容器內元素的操作更為簡單，Java引入了迭代器模式！
?Iterator中常用方法
public boolean hasNext();//判斷下一個是否有值
public E next();//先移動到下一位置取出元素；
public default void remove();//移除當前元素
?代碼實作
public class Demo1 {
public static void main(String[] args) {
Collection coll = new ArrayList();
//List<String> list = new ArrayList();//List和Set都需要先獲取iterator方法
/*Set<String> all = Set.of("1","2","3");
Iterator<String> iter = all.iterator();
*/
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
coll.add("ddd");
System.out.println(coll);
Iterator it = coll.iterator();
while (it.hasNext()) {
it.next();
it.remove();
}
System.out.println(coll);
}
}
注意：
1.next()方法和remove（）連用：使用remove()必須使用next();
2.迭代出來的元素只是迭代器copy了原集合的元素或者物件，并沒有對元素類進行改變，只是參考；
?怎么使用迭代器？
Iterator 的特點是只能單向遍歷，但是更加安全，因為它可以確保，在當前遍歷的集合元素被更改的時候，就會拋出 ConcurrentModificationException 例外，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/272225.html
標籤：java
上一篇：Map
下一篇：Spring5-idea版學習