Java學習-第一部分-第二階段-第五節：集合

来源:https://www.cnblogs.com/wenjie2000/archive/2022/08/27/16631685.html
-Advertisement-
Play Games

集合 筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html) 前面我們保存多個數據使用的是數組，那麼數組有不足的地方，我們分析一下。 ●數組 長度開始時必須指定,而且一旦指定,不能更改 保存的必須為同一類型的元素 使用數組進行增加元素的示意 ...


集合

筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html)

前面我們保存多個數據使用的是數組，那麼數組有不足的地方，我們分析一下。

●數組

  1. 長度開始時必須指定,而且一旦指定,不能更改
  2. 保存的必須為同一類型的元素
  3. 使用數組進行增加元素的示意代碼-比較麻煩

寫出Person數組擴容示意代碼。

Person[] pers = new Person[1]; // 大小是1
pers[0] = new Person();
//增加新的Person對象 ?
Person[]pers2 = new Person[pers.length + 1];//新創建數組
for(){} //拷貝pers數組的元素到pers2
pers2[pers2.length - 1] = new Person();//添加新的對象

集合

  1. 可以動態保存任意多個對象,使用比較方便!
  2. 提供了一系列方便的操作對象的方法:add、remove、set、get等
  3. 使用集合添加,刪除新元素的示意代碼-簡潔了

集合的框架體系

Java的集合類很多，主要分為兩大類,如圖:[背下來]

image

image

//老韓解讀
//1。集合主要是兩組(單列集合，雙列集合)
//2. Collection介面有兩個重要的子介面 List Set，他們的實現子類都是單列集合
//3. Map介面的實現子類是雙列集合，存放的 K-V
//4。把老師梳理的兩張圖記住
//collection
//Map
ArrayList arrayList = new ArrayList();
arrayList.add("jack ");
arrayList.add("tom");
HashMap hashMap = new HashMap();
hashMap.put("NO1", "北京");
hashMap.put("NO2","上海");

Collection

Collection介面實現類的特點

  1. collection實現子類可以存放多個元素,每個元素可以是Object
  2. 有些Collection的實現類,可以存放重覆的元素，有些不可以
  3. 有些Collection的實現類,有些是有序的(List)，有些不是有序(Set)
  4. Collection介面沒有直接的實現子類，是通過它的子介面Set 和 List來實現的

Collection介面常用方法,以實現子類ArrayList來演示.

  1. add:添加單個元素

  2. remove:刪除指定元素

  3. contains:查找元素是否存在

  4. size:獲取元素個數

  5. isEmpty:判斷是否為空

  6. clear:清空

  7. addAll:添加多個元素

  8. containsAll:查找多個元素是否都存在

  9. removeAll:刪除多個元素

  10. 說明:以ArrayList實現類來演示.

List list = new ArrayList();
//add :添加單個元素
list.add("jack");
list.add(10);//此處10自動轉為Integer類型 list.add(new Integer(10))
list.add(true);
System.out.println("list=" + list);//list=[jack, 10, true]

//remove:刪除指定元素
//list.remove(0);//刪除第一個元素
list.remove(true) ;//指定刪除某個元素
list.remove((Integer)10);//如果直接填10，java會認為是移除列表中第11個對象
System.out.println("list=" + list);//list=[jack]

//contains:查找元素是否存在
System.out.println(list.contains( "jack"));//T

//size:獲取元素個數
System.out.println(list.size());//1

//isEmpty:判斷是否為空
System.out.println(list.isEmpty());//F

//clear:清空list.clear();
list.clear();
System.out.println("list="+ list);//list=[]

//addAll:添加多個元素(只要實現了collection介面就能作為參數)
ArrayList list2 = new ArrayList();
list2.add("紅樓夢");list2.add("三國演義");
list.addAll(list2);
System.out.println("list=" + list);//list=[紅樓夢, 三國演義]

//containsAll:查找多個元素是否都存在(只要實現了collection介面就能作為參數)
System.out.println(list.containsAll(list2));//T

// removeAll:刪除多個元素
list.add("聊齋");
list.removeAll(list2);
System.out.println("list=" + list);//list=[聊齋]
//說明:以ArrayList實現類來演示。

Collection介面遍歷元素方式1-使用Iterator(迭代器)

  1. Iterator對象稱為迭代器，主要用於遍歷Collection集合中的元素。

  2. 所有實現了Collection介面的集合類都有一個iterator()方法,用以返回一個實現了lterator介面的對象,即可以返回一個迭代器。

  3. Iterator的結構.[看圖]

image

  1. Iterator僅用於遍歷集合,lterator本身並不存放對象.

提示:在調用iterator.next()方法之前必須要調用iterator.hasNext()進行檢測。若不調用，且下一條記錄無效，直接調用it.next()會拋出NoSuchElementException異常。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test {
    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);
        //現在老師希望能夠遍歷col集合
        //1。先得到col對應的迭代器
        Iterator iterator = col.iterator();
        //2．使用while迴圈遍歷
        //快捷鍵，快速生成while => itit (顯示所有的快捷鍵的的快捷鍵ctrl + j)
        while (iterator.hasNext()) {//判斷是否還有數據
            //返回下一個元素，類型是0bject
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }

        //3．當退出while迴圈後，這時iterator迭代器，指向最後的元素
        // iterator.next();//NoSuchElementException
        // 4，如果希望再次遍歷，需要重置我們的迭代器
        iterator=col.iterator();
        System.out.println( "===第二次遍歷===");
        while (iterator.hasNext()) {//判斷是否還有數據
            //返回下一個元素，類型是0bject
            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;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

Collection介面遍歷對象方式2-for迴圈增強.

增強for迴圈，可以代替iterator迭代器，特點:增強for就是簡化版的iterator,本質一樣。只能用於遍歷集合或數組。

>基本語法

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

演示

import java.util.ArrayList;
import java.util.Collection;

public class Test {
    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可以理解成就是簡化版本的迭代器遍歷
        for (Object book : col) {
            System.out.println("book=" + book);
        }
        //增強for，也可以直接在數組使用
        int[] nums = {1, 8, 10, 90};
        for (int i : nums) {
            System.out.println("i=" + i);
        }

    }
}

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;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

List

List介面基本介紹

List 介面是Collection 介面的子介面 List .java

  1. List集合類中元素有序(即添加順序和取出順序一致)、且可重覆

  2. List集合中的每個元素都有其對應的順序索引，即支持索引。（list.get(3)）

  3. List容器中的元素都對應一個整數型的序號記載其在容器中的位置,可以根據序號存取容器中的元素。

  4. JDK API中List介面的實現類佈置前文圖中展示的:

常用的有:ArrayList、LinkedList和Vector。

List介面的常用方法

List 集合里添加了一些根據索引來操作集合元素的方法

  1. void add(int index, Object ele):在index位置插入ele元素

  2. boolean addAll(int index, Collection eles):從index位置開始將eles中的所有元素添加進來

  3. Object get(int index):獲取指定index位置的元素

  4. int indexOf(Object obj):返回obj在集合中首次出現的位置

  5. int lastlndexOf(Object obj):返回obj在當前集合中末次出現的位置

  6. Object remove(int index):移除指定index位置的元素，並返回此元素

  7. Object set(int index,Object ele):設置指定index位置的元素為ele ,相當於是替換

  8. List subList(int fromlndex, int tolndex):返回從fromIndex到tolndex位置的子集合

List list = new ArrayList();
list.add("張三豐");
list.add("賈寶玉");
//void add(int index,0bject ele):在index位置插入ele元素
// 在index =1的位置插入一個對象
list.add(1, "韓順平");
System.out.println("list=" + list);
//boolean addAll(int index,Collection eles):從index位置開始將eles中的所有元素添加進來
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(0bject obj):返回obj在集合中首次出現的位置
System.out.println(list.indexOf("tom"));//2
//int lastIndexOf(Object obj):返回obj在當前集合中末次出現的位置
list.add("韓順平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韓順平"));
//Object remove(int index):移除指定index位置的元素，並返回此元素(直接修改list,而非返回新的)
list.remove(0);
System.out.println("list=" + list);
//Object set(int index，0bject ele):設置指定index位置的元素為ele，相當於是替換
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);//如果改動list元後，再列印returnlist會報錯，所以一般是即查即用
System.out.println("returnlist=" + returnlist);

List的三種遍歷方式 [ArrayList, LinkedList,Vector]

  1. 方式一:使用iterator

    lterator iter = col.iterator();
while(iter.hasNext0){
	Object o = iter.next();
}

  2. 方式二:使用增強for

    for(Object o:col){
}

  3. 方式三:使用普通for

    for(int i=o;i<list.size();i++){
    Object object = list.get(i);
    System.out.println(object);
}

說明:使用LinkedList完成使用方式和ArrayList一樣

★ArrayList

ArrayList的註意事項

  1. permits all elements, including null ,ArrayList可以加入null,並且多個
  2. ArrayList是由數組來實現數據存儲的
  3. ArrayList基本等同於Vector，除了ArrayList是線程不安全(執行效率高)看源碼.在多線程情況下，不建議使用ArrayList

ArrayList的底層操作機制源碼分析(重點，難點.)

先說結論,在分析源碼(示意圖)

  1. ArrayList中維護了一個Object類型的數組elementData. [debug 看源碼]

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

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

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

建議:自己去debug一把我們的ArrayList的創建和擴容的流程。

★Vector

Vector的基本介紹

  1. Vector類的定義說明

    public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

  2. Vector底層也是一個對象數組,protected Object[] elementData;

  3. Vector是線程同步的，即線程安全, Vector類的操作方法帶有synchronized

    public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    return elementData(index);
}

  4. 在開發中,需要線程同步安全時,考慮使用Vector

Vector和ArrayList的比較

底層結構 版本 線程安全（同步）效率 擴容倍數
ArrayList 可變數組 jdk1.2 不安全，效率高 如果有參構造1.5倍
如果是無參
1.第一次10
2.從第二次開始安1.5擴
Vector 可變數組Object[] jdk1.0 安全，效率不高 如果是無參，預設10，滿後，就按2倍擴容
如果指定大小，則每次直接按2倍擴

LinkedList

LinkedList的全面說明

  1. LinkedList底層實現了雙向鏈表和雙端隊列特點
  2. 可以添加任意元素(元素可以重覆),包括null
  3. 線程不安全,沒有實現同步

LinkedList的底層操作機制（需要有數據結構的雙向鏈表基礎）

  1. LinkedList底層維護了一個雙向鏈表.
  2. LinkedList中維護了兩個屬性first和last分別指向首節點和尾節點
  3. 每個節點(Node對象)，裡面又維護了prev、next、item三個屬性，其中通過prev指向前一個，通過next指向後一個節點。最終實現雙向鏈表。
  4. 所以LinkedList的元素的添加和刪除,不是通過數組完成的,相對來說效率較高。
  5. 模擬一個簡單的雙向鏈表【走代碼】

LinkedList的增刪改查案例

//建議用debug去看源碼
LinkedList linkedList = new LinkedList();
for (int i = 1; i <= 2; i++) {
    linkedList.add(0);
}
linkedList.add(100);
linkedList.add(100);
for (Object object : linkedList) {
    System.out.println(object);
}
// linkedList.remove(0);
// linkedList.remove(kk);

linkedList.set(0, "韓順平教育");
System.out.println("===");
for (Object object : linkedList) {
    System.out.println(object);
}
Object object = linkedList.get(0);
System.out.println("object=" + object);
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());

ArrayList和LinkedList的比較

底層結構 增刪的效率 改查的效率
ArrayList 可變數組 較低 數組擴容 較高
LinkedList 雙向鏈表 較高，通過鏈表追加 較低

如何選擇ArrayList和LinkedList:

  1. 如果我們改查的操作多，選擇ArrayList
  2. 如果我們增刪的操作多，選擇LinkedList
  3. 一般來說，在程式中，80%-90%都是查詢，因此大部分情況下會選擇ArrayList
  4. 在一個項目中，根據業務靈活選擇，也可能這樣，一個模塊使用的是ArrayList,另外一個模塊是LinkedList,也就是說,要根據業務來進行選擇

Set

Set介面基本介紹

  1. 無序（添加和取出的順序不一致)，沒有索引[後面演示]
  2. 不允許重覆元素，所以最多包含一個null

Set介面的常用方法

和List介面一樣,Set介面也是Collection的子介面，因此,常用方法和Collection介面一樣.

Set介面的遍歷方式

同Collection的遍歷方式一樣，因為Set介面是Collection介面的子介面。

  1. 可以使用迭代器
  2. 增強for
  3. 不能使用索引的方式來獲取.
//1。以Set介面的實現類 HashSet 來講解Set介面的方法
//2. set 介面的實現類的對象(Set介面對象)，不能存放重覆的元素，可以添加一個null
//3. set介面對象存放數據是無序(即添加的順序和取出的順序不一致)
//4。註意:取出的順序的順序雖然不是添加的順序，但是他的固定。
Set set = new HashSet();
set.add("john");
set.add("lucy ");
set.add("john ");//重覆  不會報錯，但也不會再次添加到set中 執行add方法後會返回boolean值,成功true,失敗false
set.add("jack");
set.add("hsp");
set.add("mary");
set.add(null);//
set.add(null);//再次添加null,  不會報錯，但也不會再次添加到set中
set.remove("jack");

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);
}

//方式2:增強for
System.out.println( "=====增強for==== ");
for (Object o : set) {
    System.out.println("o=" + o);
}
//set介面對象，不能通過索引來獲取

★HashSet

HashSet的全面說明

  1. HashSet實現了Set介面

  2. HashSet實際上是HashMap，看下源碼.

    public HashSet() {
	map = new HashMap<>();
}

  3. 可以存放null值,但是只能有一個null

  4. HashSet不保證元素是有序的,取決於hash後，再確定索引的結果.（即不保證存放和取出順序一致）

  5. 不能有重覆元素/對象.在前面Set 介面使用已經講過(主要是看對象的地址。兩個地址不同，則使用equals方法判斷，看如下案例)

    public class Test {
    public static void main(String[] args) {
        Set set = new HashSet();
        System.out.println("set=" + set); //0
        // 4 Hashset不能添加相同的元素/數據?
        set.add("lucy");//添加成功
        set.add("Lucy");//加入不了
        set.add(new Dog("tom"));//0K
        set.add(new Dog("tom"));//0k
        System.out.println("set=" + set);//set=[Dog{name='tom'}, Lucy, Dog{name='tom'}, lucy]

        //在加深一下。非常經典的面試題.
        //看源碼，做分析，先給小伙伴留一個坑，以後講完源碼，你就瞭然
        //去看他的源碼,即add到底發生了什麼?
        set.add(new String("hsp"));//ok
        set.add(new String("hsp"));//加入不了。
        System.out.println( "set=" +set);
    }
}

class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

HashSet底層機制說明

分析HashSet的添加元素底層是如何實現(hash()+equals())

  1. HashSet底層是HashMap，第一次添加時,table數組擴容到16，臨界值(threshold)是16*載入因數
    (loadFactor)是0.75 = 12
  2. 如果table數組使用到了臨界值size=12(此處的size指的是添加 的元素數量，而不是數組元素數量)，就會擴容到16*2 = 32,新的臨界值就是32*0.75 =24,依次類推
  3. 添加一個元素時，先得到hash值-會轉成->索引值
  4. 找到存儲數據表table，看這個索引位置是否已經存放的有元素
  5. 如果沒有，直接加入
  6. 如果有，調用equals比較（根據需求可在類中重寫equals()和hashCode()），如果相同，就放棄添加,如果不相同，則添加到最後
  7. 在Java8中,如果一條鏈表的元素個數大於 TREEIFY_THRESHOLD(預設是8)，並且table的大小>=
    MIN_TREEIFY_CAPACITY(預設64),就會進行樹化(紅黑樹)，否則 任採用數組擴容機制
//這裡建議debug去看源碼hashSet.add的源碼 
//筆記不方便說明，B站韓順平java課程P522和p523有詳細講解 需要重點掌握
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println("set=" + hashSet);

LinkedHashSet

LinkedHashSet底層任然調用HashSet，在它的基礎上就只是重寫了afterNodeAccess(e)，加入了雙向鏈表，使添加和取出順序相同。核心部分還是調用的HashSet源碼。

LinkedHashSet的全面說明

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

LinkedHashSet底層機制示意圖

image

說明

  1. 在LinkedHastSet中維護了一個hash表和雙向鏈表(LinkedHashSet有head和tail )
  2. 每一個節點有pre和next屬性,這樣可以形成雙向鏈表3)在添加一個元素時，先求hash值，在求索引.，確定該元素在hashtable的位置，然後將添加的元素加入到雙向鏈表(如果已經存在，不添加[原則和hashset一樣])
    tail.next = newElement //簡單指定
    newElement.pre = tail
    tail = newEelment;
  3. 這樣的話，我們遍歷LinkedHashSet 也能確保插入順序和遍歷順序一致

TreeSet

按照數據類型預設排序，也可以根據自定義內部類自定義排序（底層為TreeMap）

添加的對象對應的類要麼實現Comparable要麼自定義排序，否則會報錯（原理看源碼）

//1。當我們使用無參構造器，創建TreeSet時，是預設案編碼順序排
//2。老師希望添加的元素，按照字元串大小來排序
//3．使用TreeSet提供的一個構造器，可以傳入一個比較器(匿名內部類)
// 並指定排序規則

//TreeSet treeSet = new TreeSet();
TreeSet treeSet = new TreeSet(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //下麵調用String的 compareTo方法進行字元串大小比較
        return ((String) o2).compareTo((String) o1);//註意返回值為0時不添加，具體原因看源碼
    }
});
//添加數據。
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("a");
treeSet.add("abc");
System.out.println("treeSet=" + treeSet);

Map

Map介面實現類的特點[很實用]

註意:這裡講的是JDK8的Map介面特點

  1. Map與Collection併列存在。用於保存具有映射關係的數據:Key-Value

  2. Map 中的key和value可以是任何引用類型的數據，會封裝到HashMap$Node對象中

  3. Map中的key不允許重覆，原因和HashSet一樣,前面分析過源碼.（如果存在key相同，則會替換掉之前的key-value）

  4. Map中的value可以重覆

  5. Map 的key 可以為null, value也可以為null，註意key為null, 只能有一個,value為null,可以多個.

  6. 常用String類作為Map的key

  7. key和 value之間存在單向一對一關係,即通過指定的key總能找到對應的value（例：map.get(key)會返回value）

  8. Map存放數據的key-value示意圖,一對k-v是放在一個HashMap$Node中的，有因為Node 實現了 Entry 介面，有些書上也說一對k-v就是一個Entry

Map介面常用方法

  1. put:添加
  2. remove:根據鍵刪除映射關係
  3. get:根據鍵獲取值（例Object value=map.get(key);）
  4. size:獲取元素個數
  5. isEmpty:判斷個數是否為0
  6. clear:清除
  7. containsKey:查找鍵是否存在

Map介面遍歷方法

  1. containsKey:查找鍵是否存在

  2. keySet:獲取所有的鍵

  3. entrySet:獲取所有關係k-v

  4. values:獲取所有的值

    image

Map map = new HashMap();
map.put("鄧超", "孫儷");
map.put("王寶強", "馬蓉");
map.put("宋喆", "馬蓉");
map.put("劉令博", null);
map.put(null, "劉亦菲");
map.put("鹿啥", "關曉彤");

//第一組:先取出所有的Key ，通過Key取出對應的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<Map.Entry<K,V>>//(1）增強for
System.out.println("----使用EntrySet 的 for增強(第三種)----");
for (Object entry : entrySet) {
    //將entry 轉成 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 -實現->Hap.Entry (getKey , getValue)
    // 向下轉型 Map.Entry
    Map.Entry m = (Map.Entry) entry;
    System.out.println(m.getKey() + "-" + m.getValue());
}

★HashMap

HashMap小結

  1. Map介面的常用實現類:HashMap、Hashtable和Properties.
  2. HashMap是 Map 介面使用頻率最高的實現類。
  3. HashMap 是以 key-val對的方式來存儲數據(HashMap$Node類型)[案例Entry ]
  4. key不能重覆，但是值可以重覆,允許使用null鍵和null值。
  5. 如果添加相同的key，則會覆蓋原來的key-val,等同於修改.(key不會替換，val會替換)
  6. 與HashSet一樣，不保證映射的順序，因為底層是以hash表的方式來存儲的. (jdk8的hashMap底層數組+鏈表+紅黑樹)
  7. HashMap沒有實現同步，因此是線程不安全的,方法沒有做同步互斥的操作,沒有synchronized

HashMap底層機制及源碼剖析

擴容機制[和HashSet相司]

  1. HashMap底層維護了Node類型的數組table，預設為null
  2. 當創建對象時，將載入因數(loadfactor)初始化為0.75.
  3. 當添加key-val時，通過key的哈希值得到在table的索引。然後判斷該索引處是否有元素,如果沒有元素直接添加。如果該索引處有元素，繼續判斷該元素的key是否和準備加入的key相等，如果相等，則直接替換value；如果不相等需要判斷是樹結構還是鏈表結構，做出相應處理。如果添加時發現容量不夠，則需要擴容。
  4. 第1次添加,則需要擴容table容量為16，臨界值(threshold)為12（0.75*16）.
  5. 以後再擴容，則需要擴容table容量為原來的2倍，臨界值為原來的2倍,即24,，依次類推。
  6. 在Java8中,如果一條鏈表的元素個數超過TREEIFY_THRESHOLD(預設是8)，並且table的大小>= MIN_TREEIFY_CAPACITY(預設64),就會進行樹化(紅黑樹)

Hashtable

HashTable的基本介紹

  1. 存放的元素是鍵值對:即K-V
  2. hashtable的鍵和值都不能為null，否則會拋出NullPointerException
  3. hashTable使用方法基本上和HashMap一樣
  4. hashTable是線程安全的(synchronized), hashMap是線程不安全的
  5. 簡單看下底層結構
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);//替換
System.out.println(table);

//簡單說明一下Hashtable的底層
//1。底層有數組 Hashtable$Entry[]初始化大小為1
//2。臨界值threshold 8 = 11 * 0.75
//3．擴容:按照自己的擴容機制來進行即可.
//4.執行方法 addEntry(hash,key,value，index);添加K-V封裝到Entry
//5.當if (count >= threshold)滿足時，就進行擴容
//6.按照int newCapacity = (oldCapacity << 1) +1;的大小擴容.

Hashtable和 HashMap對比

版本 線程安全（同步） 效率 允許null建null值
HashMap 1.2 不安全 高 可以
HashTable 1.0 安全 較低 不可以

LinkedHashMap

略（底層邏輯為HashMap添加了雙向鏈表，原理如LinkedHashSet）

TreeMap

//使用預設的構造器，創建TreeMap，是無序的(也沒有排序)
/*
    要求:按照傳入的k(String)的大小進行排序
*/
//TreeMap treeMap = new TreeMap();

TreeMap treeMap = new TreeMap(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //按照傳入的 k(String)的大小進行排序
        //按照K(String)的長度大小排序
        // return ((String) o2).compareTo((String) o1);
        return ((String) o1).length() - ((String) o2).length();//註意返回值為0時不添加，具體原因看源碼
    }
});
treeMap.put("jack", "傑克");
treeMap.put("tom", "湯姆");
treeMap.put("kristina", "克瑞斯提諾");
treeMap.put("smith", "斯密斯");

System.out.println("treemap=" + treeMap);

Properties

基本介紹

  1. Properties類繼承自Hashtable類並且實現了Map介面，也是使用一種鍵值對的形式來保存數據。
  2. 他的使用特點和Hashtable類似
  3. Properties還可以用於從xxx.properties文件中，載入數據到Properties類對象,併進行讀取和修改
  4. 說明:工作後 xxx.properties文件通常作為配置文件，這個知識點在IO流舉例,有興趣可先看文章
//1. Properties繼承Hashtable
//2．可以通過k-v存放數據，當然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.get("lic"));//88

//刪除
properties.remove("lic");
System.out.println("properties=" + properties);//properties={john=100, lucy=100}

//修改
properties.put("john","約翰");
System.out.println("properties=" + properties);//properties={john=約翰, lucy=100}

//查找
System.out.println(properties.get("john"));//約翰
System.out.println(properties.getProperty("john"));//約翰

總結-開發中如何選擇集舍實現類(記住)

在開發中，選擇什麼集合實現類，主要取決於業務操作特點，然後根據集合實現類特性進行選擇，分析如下:

  1. 先判斷存儲的類型(一組對象[單列]或一組鍵值對[雙列])

  2. 一組對象:Collection介面

    允許重覆:List

    • 增刪多:LinkedList[底層維護了一個雙向鏈表]（線程不安全）
    • 改查多: ArrayList [底層維護Object類型的可變數組]（線程不安全，如果需要線程安全則用Vector）

    不允許重覆:Set

    • 無序: HashSet [底層是HashMap，維護了一個哈希表即(數組+鏈表+紅黑樹)]（線程不安全）
    • 排序:TreeSet
    • 插入和取出順序一致:LinkedHashSet，維護數組+雙向鏈表（線程不安全）

  3. 一組鍵值對:Map

    鍵無序: HashMap [底層是:哈希表jdk7:數組+鏈表，jdk8:數組+鏈表+紅黑樹]（線程不安全，如需要線程安全和key,value不為空，則使用Hashtable）

    鍵排序:TreeMap

    鍵插入和取出順序一致:LinkedHashMap（線程不安全）

    讀取文件 Properties（線程安全）

Collections工具類

Collections工具類介紹

  1. Collections是一個操作 Set、List 和Map等集合的工具類
  2. Collections中提供了一系列靜態的方法對集合元素進行排序、查詢和修改等操作

排序操作:(均為static方法)

  1. reverse(List):反轉 List 中元素的順序
  2. shuffle(List):對 List 集合元素進行隨機排序
  3. sort(List):根據元素的自然順序對指定 List集合元素按升序排序
  4. sort(List,Comparator):根據指定的 Comparator產生的順序對 List集合元素進行排序
  5. swap(List, int, int):將指定list 集合中的i處元素和j處元素進行交換
//創建ArrayList集合，用於測試。
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");

//reverse(List):反轉List 中元素的順序
Collections.reverse(list);
System.out.println("list=" + list);
//shuffle(List):對 List集合元素進行隨機排序
for (int i = 0; i < 5; i++) {
    Collections.shuffle(list);
    System.out.println("list=" + list);
}
//sort(List):根據元素的自然順序對指定 List集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序後");
System.out.println("list=" + list);
//sort(List，Comparator):根據指定的 Comparator產生的順序對List集合元素進行排序
// 我們希望按照字元串的長度大小排序
Collections.sort(list, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        return ((String) o1).length() - ((String) o2).length();
    }
});
System.out.println("字元串長度大小排序=" + list);
//swap(List，int, int):將指定 list 集合中的i處元素和j處元素進行交換
// 比如
Collections.swap(list, 0, 1);
System.out.println("交換後的情況");
System.out.println("list=" + list);

查找、替換

  1. Object max(Collection):根據元素的自然順序，返回給定集合中的最大元素
  2. Object max(Collection, Comparator):根據Comparator指定的順序,返回給定集合中的最大元素
  3. Object min(Collection)
  4. Object min(Collection,Comparator)
  5. int frequency(Collection,Object):返回指定集合中指定元素的出現次數
  6. void copy(List dest,List src):將src中的內容複製到dest中
  7. boolean replaceAll(List list, Object oldVal, Object newVal):使用新值替換 List對象的所有舊值
//創建ArrayList集合，用於測試。
List list = new ArrayList();
list.add("king");
list.add("tom");
list.add("tom");
list.add("smith");
list.add("milan");

System.out.println(list);
//object max(Collection):根據元素的自然順序，返回給定集合中的最大元素
System.out.println("自然順序最大元素=" + Collections.max(list));
//Object max(Collection,Comparator):根據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即可

ArrayList dest = new ArrayList();
//為了完成一個完整拷貝，我們需要先給dest賦值，大小大於等於list.size(),以防拷貝越界
for (int i = 0; i < list.size(); i++) {
    dest.add("");
}
dest.add("dddd");
//拷貝
Collections.copy(dest, list);//從list拷貝到dest(覆蓋dest中原先的部分數據)
System.out.println("dest=" + dest);//dest=[king, tom, tom, smith, milan, dddd]
System.out.println("list=" + list);//list=[king, tom, tom, smith, milan]

//boolean replaceAll(List list，Object oldVal，Object newNal):使用新值替換 List 對象的所有舊值
//將list中所有tom替換成湯姆
Collections.replaceAll(list, "tom", "湯姆");
System.out.println("list替換後=" + list);//list替換後=[king, 湯姆, 湯姆, smith, milan]

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Js-字元串
    字元串 字元串 字元串也是一個數據結構，將同樣的內容串在一塊。因為在對應的js裡面字元串屬於一個值類型（值類型是常量 常量是不能變）。字元串是不能改變的。結合數據結構裡面串也是一個存儲結構，作為存儲結構增刪改查的方法（字元串的增刪改查 不能針對於本身 而是返回一個新的字元串） 字元串的聲明 1.值類 ...
  • JS-數組
    數組 數據結構 數據的結構 （邏輯結構 存儲結構 演算法） 存儲結構 （數據存儲的結構方式） 線性結構 數組（順序表） 隊列 棧 堆 鏈表 非線性結構 樹 圖hash （散列表） 只要是能存數據的容器 就必須具備增刪改查的方法 數組 數組概述：數組固定一類數據的組合（一般情況下我們數組裡面的數據類型一 ...
  • 淺拷貝和深拷貝的概念及方法
    淺拷貝 只拷貝第一層的值，其他後面拷貝的是地址。 示例 使用u盤在一臺電腦上拷貝文件，使用淺拷貝拷貝的相當於快捷方式。 第一層兩個內容不一樣，其他每層都是指向同一個文件 實現淺拷貝的方法 Object.assign (實現淺拷貝) let obj = { user:{ name: " jack" } ...
  • MyBatis保姆級理解與使用，動態SQL（核心）
    1. 動態SQL（核心） 1.1 簡介 Mybatis框架的動態SQL技術是一種根據特定條件動態拼裝SQL語句的功能，它存在的意義是為瞭解決拼接SQL語句字元串時的難點問題。 比如: 我們在多條件查詢的時候會寫這樣的語句： select * from sys_user where 1=1 and 再 ...
  • DTSE Tech Talk | 雲原生架構下的數字身份治理實踐
    摘要：由華為技術大咖VS派拉軟體CTO為大家詳解雲原生架構下的身份管理平臺，構建雲安全數字身份入口。 本文分享自華為雲社區《DTSE Tech Talk | 第4期：雲原生架構下的數字身份治理實踐》，作者： 華為雲社區精選。 DTSE Tech Talk是華為雲開發者聯盟推出的技術公開課，解讀雲上前 ...
  • 《機器人SLAM導航核心技術與實戰》第1季：第2章_C++編程範式
    《機器人SLAM導航核心技術與實戰》第1季：第2章_C++編程範式 視頻講解 【第1季】2.第2章_C++編程範式-視頻講解 【第1季】2.1.第2章_C++編程範式-C++工程的組織結構-視頻講解 【第1季】2.2.第2章_C++編程範式-C++代碼的編譯方法-視頻講解 【第1季】2.3.第2章_ ...
  • 操作系統的介紹
    操作系統的介紹 1.什麼是操作系統 操作系統其實就是一個協調、管理、控制電腦硬體資源和軟體資源的一個控製程序 2.為什麼要有操作系統 （1）可以控制電腦硬體的基本運行 （2）把操作硬體的複雜操作封裝成一個簡單的功能，交給上層的應用程式使用。例如文件就是操作系統提供給應用程式的一種功能！ 3.程式 ...
  • 刨析一下C++構造析構函數能不能聲明為虛函數的背後機理？
    以下內容為本人的著作，如需要轉載，請聲明原文鏈接 微信公眾號「englyf」https://www.cnblogs.com/englyf/p/16631774.html 先說結論： 構造函數不能聲明為虛函數，析構函數可以聲明為虛函數。 構造函數可以聲明為虛函數嗎？ 虛函數表裡都存了些什麼東西？不是金 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類