vue3中使用vite-ts構建專案時vite.config的配置

阿新 • • 發佈：2022-03-04

Collection集合

集合概述

集合：集合是java中提供的一種容器，可以用來儲存多個數據。

集合和陣列既然都是容器，它們有啥區別呢？

陣列的長度是固定的。集合的長度是可變的。
陣列中儲存的是同一型別的元素，可以儲存基本資料型別值。集合儲存的都是物件。而且物件的型別可以不一致。在開發中一般當物件多的時候，使用集合進行儲存。

集合框架

JAVASE提供了滿足各種需求的API，在使用這些API前，先了解其繼承與介面操作架構，才能瞭解何時採用哪個類，以及類之間如何彼此合作，從而達到靈活應用。

集合按照其儲存結構可以分為兩大類，分別是單列集合java.util.Collection和雙列集合java.util.Map

Collection：單列集合類的根介面，用於儲存一系列符合某種規則的元素，它有兩個重要的子介面，分別是java.util.List和java.util.Set。其中，List的特點是元素有序、元素可重複。Set的特點是元素無序，而且不可重複。List介面的主要實現類有java.util.ArrayList和java.util.LinkedList，Set介面的主要實現類有java.util.HashSet和java.util.TreeSet。

接下來通過一張圖來描述整個集合類的繼承體系。

集合本身是一個工具，它存放在java.util包中。在Collection介面定義著單列集合框架中最最共性的內容。

Collection 常用功能

Collection是所有單列集合的父介面，因此在Collection中定義了單列集合(List和Set)通用的一些方法，這些方法可用於操作所有的單列集合。方法如下：

public boolean add(E e)：把給定的物件新增到當前集合中。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把給定的物件在當前集合中刪除。
public boolean contains(E e): 判斷當前集合中是否包含給定的物件。
public boolean isEmpty(): 判斷當前集合是否為空。

public int size(): 返回集合中元素的個數。
public Object[] toArray(): 把集合中的元素，儲存到陣列中。

方法演示：

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

public class Demo1Collection {
    public static void main(String[] args) {
		  // 建立集合物件 
    	// 使用多型形式
    	Collection<String> coll = new ArrayList<String>();
    	// 使用方法
    	// 新增功能  boolean  add(String s)
    	coll.add("小李廣");
    	coll.add("掃地僧");
    	coll.add("石破天");
    	System.out.println(coll);

    	// boolean contains(E e) 判斷o是否在集合中存在
    	System.out.println("判斷  掃地僧 是否在集合中"+coll.contains("掃地僧"));

    	//boolean remove(E e) 刪除在集合中的o元素
    	System.out.println("刪除石破天："+coll.remove("石破天"));
    	System.out.println("操作之後集合中元素:"+coll);
    	
    	// size() 集合中有幾個元素
		System.out.println("集合中有"+coll.size()+"個元素");

		// Object[] toArray()轉換成一個Object陣列
    	Object[] objects = coll.toArray();
    	// 遍歷陣列
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中內容為："+coll);
		// boolean  isEmpty()  判斷是否為空
		System.out.println(coll.isEmpty());  	
	}
}

tips: 有關Collection中的方法可不止上面這些，其他方法可以自行檢視API學習。

Iterator迭代器

Iterator介面

在程式開發中，經常需要遍歷集合中的所有元素。針對這種需求，JDK專門提供了一個介面java.util.Iterator。Iterator介面也是Java集合中的一員，但它與Collection、Map介面有所不同，Collection介面與Map介面主要用於儲存元素，而Iterator主要用於迭代訪問（即遍歷）Collection中的元素，因此Iterator物件也被稱為迭代器。

想要遍歷Collection集合，那麼就要獲取該集合迭代器完成迭代操作，下面介紹一下獲取迭代器的方法：

public Iterator iterator(): 獲取集合對應的迭代器，用來遍歷集合中的元素的。

下面介紹一下迭代的概念：

迭代：即Collection集合元素的通用獲取方式。在取元素之前先要判斷集合中有沒有元素，如果有，就把這個元素取出來，繼續在判斷，如果還有就再取出出來。一直把集合中的所有元素全部取出。這種取出方式專業術語稱為迭代。

Iterator介面的常用方法如下：

public E next():返回迭代的下一個元素。
public boolean hasNext():如果仍有元素可以迭代，則返回 true。

接下來我們通過案例學習如何使用Iterator迭代集合中元素：

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多型方式 建立物件
        Collection<String> coll = new ArrayList<String>();

        // 新增元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍歷
        //使用迭代器 遍歷   每個集合物件都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的資料型別
        while(it.hasNext()){ //判斷是否有迭代元素
            String s = it.next();//獲取迭代出的元素
            System.out.println(s);
        }
  	}
}

tips:：在進行集合元素取出時，如果集合中已經沒有元素了，還繼續使用迭代器的next方法，將會發生java.util.NoSuchElementException沒有集合元素的錯誤。

增強for

增強for迴圈(也稱for each迴圈)是JDK1.5以後出來的一個高階for迴圈，專門用來遍歷陣列和集合的。它的內部原理其實是個Iterator迭代器，所以在遍歷的過程中，不能對集合中的元素進行增刪操作。

格式：

for(元素的資料型別  變數 : Collection集合or陣列){ 
  	//寫操作程式碼
}

它用於遍歷Collection和陣列。通常只進行遍歷元素，不要在遍歷的過程中對集合元素進行增刪操作。

練習1:遍歷陣列

public class NBForDemo1 {
    public static void main(String[] args) {
		int[] arr = {3,5,6,87};
       	//使用增強for遍歷陣列
		for(int a : arr){//a代表陣列中的每個元素
			System.out.println(a);
		}
	}
}

練習2:遍歷集合

public class NBFor {
    public static void main(String[] args) {        
    	Collection<String> coll = new ArrayList<String>();
    	coll.add("小河神");
    	coll.add("老河神");
    	coll.add("神婆");
    	//使用增強for遍歷
    	for(String s :coll){//接收變數s代表 代表被遍歷到的集合元素
    		System.out.println(s);
    	}
	}
}

tips: 新for迴圈必須有被遍歷的目標。目標只能是Collection或者是陣列。新式for僅僅作為遍歷操作出現。

List集合

學習Collection中的常用幾個子類（java.util.List集合、java.util.Set集合）。

List介面介紹

java.util.List介面繼承自Collection介面，是單列集合的一個重要分支，習慣性地會將實現了List介面的物件稱為List集合。在List集合中允許出現重複的元素，所有的元素是以一種線性方式進行儲存的，在程式中可以通過索引來訪問集合中的指定元素。另外，List集合還有一個特點就是元素有序，即元素的存入順序和取出順序一致。

List介面特點：

它是一個元素存取有序的集合。例如，存元素的順序是11、22、33。那麼集合中，元素的儲存就是按照11、22、33的順序完成的）。
它是一個帶有索引的集合，通過索引就可以精確的操作集合中的元素（與陣列的索引是一個道理）。
集合中可以有重複的元素，通過元素的equals方法，來比較是否為重複的元素。

List介面中常用方法

List作為Collection集合的子介面，不但繼承了Collection介面中的全部方法，而且還增加了一些根據元素索引來操作集合的特有方法，如下：

public void add(int index, E element): 將指定的元素，新增到該集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element):用指定元素替換集合中指定位置的元素,返回值的更新前的元素。

List集合特有的方法都是跟索引相關

public class ListDemo {
    public static void main(String[] args) {
		// 建立List集合物件
    	List<String> list = new ArrayList<String>();
    	
    	// 往 尾部新增 指定元素
    	list.add("圖圖");
    	list.add("小美");
    	list.add("不高興");
    	
    	System.out.println(list);
    	// add(int index,String s) 往指定位置新增
    	list.add(1,"沒頭腦");
    	
    	System.out.println(list);
    	// String remove(int index) 刪除指定位置元素  返回被刪除元素
    	// 刪除索引位置為2的元素 
    	System.out.println("刪除索引位置為2的元素");
    	System.out.println(list.remove(2));
    	
    	System.out.println(list);
    	
    	// String set(int index,String s)
    	// 在指定位置 進行 元素替代（改） 
    	// 修改指定位置元素
    	list.set(0, "三毛");
    	System.out.println(list);
    	
    	// String get(int index)  獲取指定位置元素
    	
    	// 跟size() 方法一起用  來 遍歷的 
    	for(int i = 0;i<list.size();i++){
    		System.out.println(list.get(i));
    	}
    	//還可以使用增強for
    	for (String string : list) {
			System.out.println(string);
		}  	
	}
}

List的子類

ArrayList集合

java.util.ArrayList集合資料儲存的結構是陣列結構。元素增刪慢，查詢快，由於日常開發中使用最多的功能為查詢資料、遍歷資料，所以ArrayList是最常用的集合。

LinkedList集合

java.util.LinkedList集合資料儲存的結構是連結串列結構。方便元素新增、刪除的集合。

LinkedList是一個雙向連結串列，那麼雙向連結串列是什麼樣子的呢，我們用個圖瞭解下

實際開發中對一個集合元素的新增與刪除經常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。這些方法我們作為了解即可：

public void addFirst(E e):將指定元素插入此列表的開頭。
public void addLast(E e):將指定元素新增到此列表的結尾。
public E getFirst():返回此列表的第一個元素。
public E getLast():返回此列表的最後一個元素。
public E removeFirst():移除並返回此列表的第一個元素。
public E removeLast():移除並返回此列表的最後一個元素。
public E pop():從此列表所表示的堆疊處彈出一個元素。
public void push(E e):將元素推入此列表所表示的堆疊。
public boolean isEmpty()：如果列表不包含元素，則返回true。

LinkedList是List的子類，List中的方法LinkedList都是可以使用，這裡就不做詳細介紹，我們只需要瞭解LinkedList的特有方法即可。在開發時，LinkedList集合也可以作為堆疊，佇列的結構使用。（瞭解即可）

方法演示：

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        //新增元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        System.out.println(link);
        // 獲取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        // 刪除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());

        while (!link.isEmpty()) { //判斷集合是否為空
            System.out.println(link.pop()); //彈出集合中的棧頂元素
        }

        System.out.println(link);
    }
}

Set介面

java.util.Set介面和java.util.List介面一樣，同樣繼承自Collection介面，它與Collection介面中的方法基本一致，並沒有對Collection介面進行功能上的擴充，只是比Collection介面更加嚴格了。與List介面不同的是，Set介面中元素無序，並且都會以某種規則保證存入的元素不出現重複。

Set集合有多個子類，這裡我們介紹其中的java.util.HashSet、java.util.LinkedHashSet這兩個集合。

tips:Set集合取出元素的方式可以採用：迭代器、增強for。

HashSet集合介紹

java.util.HashSet是Set介面的一個實現類，它所儲存的元素是不可重複的，並且元素都是無序的(即存取順序不一致)。java.util.HashSet底層的實現其實是一個java.util.HashMap支援。

HashSet是根據物件的雜湊值來確定元素在集合中的儲存位置，因此具有良好的存取和查詢效能。保證元素唯一性的方式依賴於：hashCode與equals方法。

我們先來使用一下Set集合儲存，看下現象，再進行原理的講解:

public class HashSetDemo {
    public static void main(String[] args) {
        //建立 Set集合
        HashSet<String>  set = new HashSet<String>();

        //新增元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac"); 
        set.add("cba");  
        //遍歷
        for (String name : set) {
            System.out.println(name);
        }
    }
}
//輸出結果如下，說明集合中不能儲存重複元素：
cba
abc
bac

HashSet集合儲存資料的結構（雜湊表）

什麼是雜湊表呢？

在JDK1.8之前，雜湊表底層採用陣列+連結串列實現，即使用連結串列處理衝突，同一hash值的連結串列都儲存在一個連結串列裡。但是當位於一個桶中的元素較多，即hash值相等的元素較多時，通過key值依次查詢的效率較低。而JDK1.8中，雜湊表儲存採用陣列+連結串列+紅黑樹實現，當連結串列長度超過閾值（8）時，將連結串列轉換為紅黑樹，這樣大大減少了查詢時間。

簡單的來說，雜湊表是由陣列+連結串列+紅黑樹（JDK1.8增加了紅黑樹部分）實現的，如下圖所示。

看到這張圖就有人要問了，這個是怎麼儲存的呢？

為了方便大家的理解我們結合一個儲存流程圖來說明一下：

總而言之，JDK1.8引入紅黑樹大程度優化了HashMap的效能，那麼對於我們來講保證HashSet集合元素的唯一，其實就是根據物件的hashCode和equals方法來決定的。如果我們往集合中存放自定義的物件，那麼保證其唯一，就必須複寫hashCode和equals方法建立屬於當前物件的比較方式。

HashSet儲存自定義型別元素

給HashSet中存放自定義型別元素時，需要重寫物件中的hashCode和equals方法，建立自己的比較方式，才能保證HashSet集合中的物件唯一

建立自定義Student類

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class HashSetDemo2 {
    public static void main(String[] args) {
        //建立集合物件   該集合中儲存 Student型別物件
        HashSet<Student> stuSet = new HashSet<Student>();
        //儲存 
        Student stu = new Student("于謙", 43);
        stuSet.add(stu);
        stuSet.add(new Student("郭德綱", 44));
        stuSet.add(new Student("于謙", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}
執行結果：
Student [name=郭德綱, age=44]
Student [name=于謙, age=43]
Student [name=郭麒麟, age=23]

LinkedHashSet

我們知道HashSet保證元素唯一，可是元素存放進去是沒有順序的，那麼我們要保證有序，怎麼辦呢？

在HashSet下面有一個子類java.util.LinkedHashSet，它是連結串列和雜湊表組合的一個數據儲存結構。

演示程式碼如下:

public class LinkedHashSetDemo {
	public static void main(String[] args) {
		Set<String> set = new LinkedHashSet<String>();
		set.add("bbb");
		set.add("aaa");
		set.add("abc");
		set.add("bbc");
        Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
結果：
  bbb
  aaa
  abc
  bbc

可變引數

在JDK1.5之後，如果我們定義一個方法需要接受多個引數，並且多個引數型別一致，我們可以對其簡化成如下格式：

修飾符 返回值型別 方法名(引數型別... 形參名){  }

其實這個書寫完全等價與

修飾符 返回值型別 方法名(引數型別[] 形參名){  }

只是後面這種定義，在呼叫時必須傳遞陣列，而前者可以直接傳遞資料即可。

JDK1.5以後。出現了簡化操作。... 用在引數上，稱之為可變引數。

同樣是代表陣列，但是在呼叫這個帶有可變引數的方法時，不用建立陣列(這就是簡單之處)，直接將陣列中的元素作為實際引數進行傳遞，其實編譯成的class檔案，將這些元素先封裝到一個數組中，在進行傳遞。這些動作都在編譯.class檔案時，自動完成了。

程式碼演示：

public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
        //  6  7  2 12 2121
        // 求 這幾個元素和 6  7  2 12 2121
        int sum2 = getSum(6, 7, 2, 12, 2121);
        System.out.println(sum2);
    }

    /*
     * 完成陣列  所有元素的求和 原始寫法
     
      public static int getSum(int[] arr){
        int sum = 0;
        for(int a : arr){
            sum += a;
        }
        
        return sum;
      }
    */
    //可變引數寫法
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        return sum;
    }
}

tips: 上述add方法在同一個類中，只能存在一個。因為會發生呼叫的不確定性

注意：如果在方法書寫時，這個方法擁有多引數，引數中包含可變引數，可變引數一定要寫在引數列表的末尾位置。

Collections

常用功能

java.utils.Collections是集合工具類，用來對集合進行操作。部分方法如下：

public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中新增一些元素。
public static void shuffle(List<?> list) 打亂順序:打亂集合順序。
public static <T> void sort(List<T> list):將集合中元素按照預設規則排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):將集合中元素按照指定規則排序。

程式碼演示：

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //原來寫法
        //list.add(12);
        //list.add(14);
        //list.add(15);
        //list.add(1000);
        //採用工具類 完成 往集合中新增元素  
        Collections.addAll(list, 5, 222, 1，2);
        System.out.println(list);
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}
結果：
[5, 222, 1, 2]
[1, 2, 5, 222]

程式碼演示之後，發現我們的集合按照順序進行了排列，可是這樣的順序是採用預設的順序，如果想要指定順序那該怎麼辦呢？

我們發現還有個方法沒有講，public static <T> void sort(List<T> list，Comparator<? super T> ):將集合中元素按照指定規則排序。接下來講解一下指定規則的排列。

Comparator比較器

我們還是先研究這個方法

public static <T> void sort(List<T> list):將集合中元素按照預設規則排序。

不過這次儲存的是字串型別。

public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法
        Collections.sort(list);
        System.out.println(list);
    }
}

結果：

[aba, cba, nba, sba]

我們使用的是預設的規則完成字串的排序，那麼預設規則是怎麼定義出來的呢？

說到排序了，簡單的說就是兩個物件之間比較大小，那麼在JAVA中提供了兩種比較實現的方式，一種是比較死板的採用java.lang.Comparable介面去實現，一種是靈活的當我需要做排序的時候在去選擇的java.util.Comparator介面完成。

那麼我們採用的public static <T> void sort(List<T> list)這個方法完成的排序，實際上要求了被排序的型別需要實現Comparable介面完成比較的功能，在String型別上如下：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

String類實現了這個介面，並完成了比較規則的定義，但是這樣就把這種規則寫死了，那比如我想要字串按照第一個字元降序排列，那麼這樣就要修改String的原始碼，這是不可能的了，那麼這個時候我們可以使用

public static <T> void sort(List<T> list，Comparator<? super T> )方法靈活的完成，這個裡面就涉及到了Comparator這個介面，位於位於java.util包下，排序是comparator能實現的功能之一,該介面代表一個比較器，比較器具有可比性！顧名思義就是做排序的，通俗地講需要比較兩個物件誰排在前誰排在後，那麼比較的方法就是：

public int compare(String o1, String o2)：比較其兩個引數的順序。

兩個物件比較的結果有三種：大於，等於，小於。

如果要按照升序排序，
則o1 小於o2，返回（負數），相等返回0，01大於02返回（正數）
如果要按照降序排序
則o1 小於o2，返回（正數），相等返回0，01大於02返回（負數）

操作如下:

public class CollectionsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一個單詞的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0) - o1.charAt(0);
            }
        });
        System.out.println(list);
    }
}

結果如下：

[sba, nba, cba, aba]

簡述Comparable和Comparator兩個介面的區別。

Comparable：強行對實現它的每個類的物件進行整體排序。這種排序被稱為類的自然排序，類的compareTo方法被稱為它的自然比較方法。只能在類中實現compareTo()一次，不能經常修改類的程式碼實現自己想要的排序。實現此介面的物件列表（和陣列）可以通過Collections.sort（和Arrays.sort）進行自動排序，物件可以用作有序對映中的鍵或有序集合中的元素，無需指定比較器。

Comparator強行對某個物件進行整體排序。可以將Comparator 傳遞給sort方法（如Collections.sort或 Arrays.sort），從而允許在排序順序上實現精確控制。還可以使用Comparator來控制某些資料結構（如有序set或有序對映）的順序，或者為那些沒有自然順序的物件collection提供排序。

Map集合

概述

現實生活中，我們常會看到這樣的一種集合：IP地址與主機名，身份證號與個人，系統使用者名稱與系統使用者物件等，這種一一對應的關係，就叫做對映。Java提供了專門的集合類用來存放這種物件關係的物件，即java.util.Map介面。

我們通過檢視Map介面描述，發現Map介面下的集合與Collection介面下的集合，它們儲存資料的形式不同，如下圖。

Collection中的集合，元素是孤立存在的（理解為單身），向集合中儲存元素採用一個個元素的方式儲存。
Map中的集合，元素是成對存在的(理解為夫妻)。每個元素由鍵與值兩部分組成，通過鍵可以找對所對應的值。
Collection中的集合稱為單列集合，Map中的集合稱為雙列集合。
需要注意的是，Map中的集合不能包含重複的鍵，值可以重複；每個鍵只能對應一個值。

Map常用子類

通過檢視Map介面描述，看到Map有多個子類，這裡我們主要講解常用的HashMap集合、LinkedHashMap集合。

HashMap<K,V>：儲存資料採用的雜湊表結構，元素的存取順序不能保證一致。由於要保證鍵的唯一、不重複，需要重寫鍵的hashCode()方法、equals()方法。
LinkedHashMap<K,V>：HashMap下有個子類LinkedHashMap，儲存資料採用的雜湊表結構+連結串列結構。通過連結串列結構可以保證元素的存取順序一致；通過雜湊表結構可以保證的鍵的唯一、不重複，需要重寫鍵的hashCode()方法、equals()方法。

tips：Map介面中的集合都有兩個泛型變數<K,V>,在使用時，要為兩個泛型變數賦予資料型別。兩個泛型變數<K,V>的資料型別可以相同，也可以不同。

Map介面中的常用方法

Map介面中定義了很多方法，常用的如下：

public V put(K key, V value): 把指定的鍵與指定的值新增到Map集合中。
public V remove(Object key): 把指定的鍵所對應的鍵值對元素在Map集合中刪除，返回被刪除元素的值。
public V get(Object key) 根據指定的鍵，在Map集合中獲取對應的值。
boolean containsKey(Object key) 判斷集合中是否包含指定的鍵。
public Set<K> keySet(): 獲取Map集合中所有的鍵，儲存到Set集合中。
public Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中所有的鍵值對物件的集合(Set集合)。

Map介面的方法演示

public class MapDemo {
    public static void main(String[] args) {
        //建立 map物件
        HashMap<String, String>  map = new HashMap<String, String>();

        //新增元素到集合
        map.put("黃曉明", "楊穎");
        map.put("文章", "馬伊琍");
        map.put("鄧超", "孫儷");
        System.out.println(map);

        //String remove(String key)
        System.out.println(map.remove("鄧超"));
        System.out.println(map);

        // 想要檢視 黃曉明的媳婦 是誰
        System.out.println(map.get("黃曉明"));
        System.out.println(map.get("鄧超"));    
    }
}

tips:

使用put方法時，若指定的鍵(key)在集合中沒有，則沒有這個鍵對應的值，返回null，並把指定的鍵值新增到集合中；

若指定的鍵(key)在集合中存在，則返回值為集合中鍵對應的值（該值為替換前的值），並把指定鍵所對應的值，替換成指定的新值。

Map集合遍歷鍵找值方式

鍵找值方式：即通過元素中的鍵，獲取鍵所對應的值

分析步驟：

獲取Map中所有的鍵，由於鍵是唯一的，所以返回一個Set集合儲存所有的鍵。方法提示:keyset()
遍歷鍵的Set集合，得到每一個鍵。
根據鍵，獲取鍵所對應的值。方法提示:get(K key)

程式碼演示：

public class MapDemo01 {
    public static void main(String[] args) {
        //建立Map集合物件 
        HashMap<String, String> map = new HashMap<String,String>();
        //新增元素到集合 
        map.put("胡歌", "霍建華");
        map.put("郭德綱", "于謙");
        map.put("薛之謙", "大張偉");

        //獲取所有的鍵  獲取鍵集
        Set<String> keys = map.keySet();
        // 遍歷鍵集 得到 每一個鍵
        for (String key : keys) {
          	//key  就是鍵
            //獲取對應值
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        }  
    }
}

遍歷圖解：

Entry鍵值對物件

我們已經知道，Map中存放的是兩種物件，一種稱為key(鍵)，一種稱為value(值)，它們在在Map中是一一對應關係，這一對物件又稱做Map中的一個Entry(項)。Entry將鍵值對的對應關係封裝成了物件。即鍵值對物件，這樣我們在遍歷Map集合時，就可以從每一個鍵值對（Entry）物件中獲取對應的鍵與對應的值。

既然Entry表示了一對鍵和值，那麼也同樣提供了獲取對應鍵和對應值得方法：

public K getKey()：獲取Entry物件中的鍵。
public V getValue()：獲取Entry物件中的值。

在Map集合中也提供了獲取所有Entry物件的方法：

public Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中所有的鍵值對物件的集合(Set集合)。

Map集合遍歷鍵值對方式

鍵值對方式：即通過集合中每個鍵值對(Entry)物件，獲取鍵值對(Entry)物件中的鍵與值。

操作步驟與圖解：

獲取Map集合中，所有的鍵值對(Entry)物件，以Set集合形式返回。方法提示:entrySet()。
遍歷包含鍵值對(Entry)物件的Set集合，得到每一個鍵值對(Entry)物件。
通過鍵值對(Entry)物件，獲取Entry物件中的鍵與值。方法提示:getkey() getValue()

public class MapDemo02 {
    public static void main(String[] args) {
        // 建立Map集合物件 
        HashMap<String, String> map = new HashMap<String,String>();
        // 新增元素到集合 
        map.put("胡歌", "霍建華");
        map.put("郭德綱", "于謙");
        map.put("薛之謙", "大張偉");

        // 獲取 所有的 entry物件  entrySet
        Set<Entry<String,String>> entrySet = map.entrySet();

        // 遍歷得到每一個entry物件
        for (Entry<String, String> entry : entrySet) {
           	// 解析 
            String key = entry.getKey();
            String value = entry.getValue();  
            System.out.println(key+"的CP是:"+value);
        }
    }
}

遍歷圖解：

tips：Map集合不能直接使用迭代器或者foreach進行遍歷。但是轉成Set之後就可以使用了。

HashMap儲存自定義型別鍵值

練習：每位學生（姓名，年齡）都有自己的家庭住址。那麼，既然有對應關係，則將學生物件和家庭住址儲存到map集合中。學生作為鍵, 家庭住址作為值。

注意，學生姓名相同並且年齡相同視為同一名學生。

編寫學生類：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

編寫測試類：

public class HashMapTest {
    public static void main(String[] args) {
        //1,建立Hashmap集合物件。
        Map<Student,String>map = new HashMap<Student,String>();
        //2,新增元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25), "廣州");
        map.put(newStudent("wangwu",22), "南京");
        
        //3,取出元素。鍵找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            Stringvalue = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }
}

當給HashMap中存放自定義物件時，如果自定義物件作為key存在，這時要保證物件唯一，必須複寫物件的hashCode和equals方法(如果忘記，請回顧HashSet存放自定義物件)。
如果要保證map中存放的key和取出的順序一致，可以使用java.util.LinkedHashMap集合來存放。

LinkedHashMap

我們知道HashMap保證成對元素唯一，並且查詢速度很快，可是成對元素存放進去是沒有順序的，那麼我們要保證有序，還要速度快怎麼辦呢？

在HashMap下面有一個子類LinkedHashMap，它是連結串列和雜湊表組合的一個數據儲存結構。

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("鄧超", "孫儷");
        map.put("李晨", "范冰冰");
        map.put("劉德華", "朱麗倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
    }
}

結果:

鄧超  孫儷
李晨  范冰冰
劉德華  朱麗倩

我們欠生活一個努力！

vue3中使用vite-ts構建專案時vite.config的配置

Collection集合

集合概述

集合框架

Collection 常用功能

Iterator迭代器

Iterator介面

增強for

練習1:遍歷陣列

練習2:遍歷集合

List集合

List介面介紹

List介面中常用方法

List的子類

ArrayList集合

LinkedList集合

Set介面

HashSet集合介紹

HashSet集合儲存資料的結構（雜湊表）

HashSet儲存自定義型別元素

LinkedHashSet

可變引數

Collections

常用功能

Comparator比較器

簡述Comparable和Comparator兩個介面的區別。

Map集合

概述

Map常用子類

Map介面中的常用方法

Map集合遍歷鍵找值方式

Entry鍵值對物件

Map集合遍歷鍵值對方式

HashMap儲存自定義型別鍵值

LinkedHashMap

相關推薦