內容：List、Set、數據結構、Collections

List集合
Set集合
Collections

第一章 List集合

1.1 List接口介紹

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

List接口特點：

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

tips:我們在基礎班的時候已經學習過List接口的子類java.util.ArrayList類，該類中的方法都是來自List中定義。

1.2 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的子類

3.1 ArrayList集合

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

許多程序員開發時非常隨意地使用ArrayList完成任何需求，這種用法是不提倡的。

3.2 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集合也可以作爲堆棧，隊列的結構使用。

方法演示：

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。

3.1 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

tips:根據結果我們發現字符串"cba"只存儲了一個，也就是說重複的元素set集合不存儲。

2.2 HashSet集合存儲數據的結構（哈希表）

什麼是哈希表呢？

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

簡單的來說，哈希表是由數組+鏈表+紅黑樹（JDK1.8增加了紅黑樹部分）實現的。

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

2.3 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]

2.3 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

1.9 可變參數

在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

2.1 常用功能

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> ):將集合中元素按照指定規則排序。接下來講解一下指定規則的排列。

2.2 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]

2.3 簡述Comparable和Comparator兩個接口的區別。

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

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

`方法使用示例展示：`

創建一個學生類，存儲到ArrayList集合中完成指定排序操作。

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 String toString() {
        return "Student{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
    }
}

測試類：

public class Demo {

    public static void main(String[] args) {
        // 創建四個學生對象 存儲到集合中
        ArrayList<Student> list = new ArrayList<Student>();

        list.add(new Student("rose",18));
        list.add(new Student("jack",16));
        list.add(new Student("abc",16));
        list.add(new Student("ace",17));
        list.add(new Student("mark",16));


        /*
          讓學生 按照年齡排序 升序
         */
//        Collections.sort(list);//要求 該list中元素類型  必須實現比較器Comparable接口


        for (Student student : list) {
            System.out.println(student);
        }


    }
}

發現，當我們調用Collections.sort()方法的時候程序報錯了。

原因：如果想要集合中的元素完成排序，那麼必須要實現比較器Comparable接口。

於是我們就完成了Student類的一個實現，如下：

public class Student implements Comparable<Student>{
    ....
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//升序
    }
}

再次測試，代碼就OK 了效果如下：

Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}
Student{name='ace', age=17}
Student{name='rose', age=18}

2.5 擴展

如果在使用的時候，想要獨立的定義規則去使用可以採用Collections.sort(List list,Comparetor c)方式，自己定義規則：

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge()-o1.getAge();//以學生的年齡降序
    }
});

效果：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}

如果想要規則更多一些，可以參考下面代碼：

Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 年齡降序
                int result = o2.getAge()-o1.getAge();//年齡降序

                if(result==0){//第一個規則判斷完了 下一個規則 姓名的首字母 升序
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }

                return result;
            }
        });

效果如下：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}

3-List&&Set&&數據結構&&Collections概述

內容：List、Set、數據結構、Collections

第一章 List集合

1.1 List接口介紹

1.2 List接口中常用方法

第三章 List的子類

3.1 ArrayList集合

3.2 LinkedList集合

第四章 Set接口

3.1 HashSet集合介紹

2.2 HashSet集合存儲數據的結構（哈希表）

2.3 HashSet存儲自定義類型元素

2.3 LinkedHashSet

1.9 可變參數

第五章 Collections

2.1 常用功能

2.2 Comparator比較器

2.3 簡述Comparable和Comparator兩個接口的區別。

`方法使用示例展示：`

2.5 擴展

.Net 8.0 下的新RPC，IceRPC之試試的新玩法"打洞"

完美替代postman的軟件

Vue mockjs mock.js

關於遊戲付費的一點想法

我通過CKA和CKS啦！

安裝chromadb注意事項

《最新出爐》系列入門篇-Python+Playwright自動化測試-42-強大的可視化追蹤利器Trace Viewer

大數據怎麼學？對大數據開發領域及崗位的詳細解讀，完整理解大數據開發領域技術體系

Junit測試類、註解、元註解個人小結

MySQL數據庫常用語法|JDBC、Template常用方法歸納

基於MybatisPlus的多表查詢

HTML 複習查漏補缺筆記

HTTP協議格式分析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結