七、類庫(kù)

源碼、字節(jié)碼與幫助文檔

1. 源碼：

   • 理解程序：源碼是程序員編寫的原始代碼，用于理解程序的邏輯和功能。

2. 字節(jié)碼：

   • 程序開發(fā)使用：字節(jié)碼是源碼編譯后的中間代碼，由JVM執(zhí)行。它是跨平臺(tái)的，可以在任何支持JVM的系統(tǒng)上運(yùn)行。

3. 幫助文檔：

   • 對(duì)開發(fā)提供幫助：幫助文檔是開發(fā)者的參考指南，通常通過(guò)javadoc生成。
   • 注意使用版本同一：確保使用的幫助文檔與代碼版本一致，避免因版本差異導(dǎo)致的錯(cuò)誤。

Object類（根類）

Object是Java中所有類的根類，提供了一些核心方法：

1. protected Object clone()：

   • 負(fù)責(zé)對(duì)象克隆，返回對(duì)象的副本。

2. boolean equals(Object obj)：

   • 判斷兩個(gè)對(duì)象是否相等。默認(rèn)比較引用地址，通常需要重寫以比較對(duì)象內(nèi)容。

3. int hashCode()：

   • 返回對(duì)象的哈希代碼值，用于哈希表等數(shù)據(jù)結(jié)構(gòu)。

4. String toString()：

   • 返回對(duì)象的字符串表示形式。默認(rèn)返回類名@哈希值，通常需要重寫以提供更有意義的信息。

5. protected void finalize() throws Throwable：

   • 垃圾回收器負(fù)責(zé)調(diào)用，用于對(duì)象銷毀前的清理工作。

6. System.gc()：

   • 建議啟動(dòng)垃圾回收器，但不保證立即執(zhí)行。

System類

System類提供了一些系統(tǒng)級(jí)別的操作：

1. System.gc()：

   • 建議啟動(dòng)垃圾回收器。

2. System.out：

   • 靜態(tài)變量，用于控制臺(tái)輸出。

3. System.out.print()：

   • 輸出打印不換行。

4. System.out.println()：

   • 換行輸出。

5. System.currentTimeMillis()：

   • 獲取自1970年1月1日00:00:00到當(dāng)前系統(tǒng)時(shí)間的總毫秒數(shù)。

6. System.exit(0)：

   • 退出JVM。

Arrays類

Arrays是數(shù)組工具類，提供了一些常用方法：

1. Arrays.sort(arr)：

   • 對(duì)數(shù)組進(jìn)行排序。

2. Arrays.binarySearch(arr, key)：

   • 使用二分法查找元素，不存在時(shí)返回-1。

String類

String類用于操作字符串，提供了豐富的構(gòu)造方法和方法：

1. 構(gòu)造方法：

   • String(byte[] byte)：將字節(jié)數(shù)組轉(zhuǎn)換為字符串。
   • String(char[] char)：將字符數(shù)組轉(zhuǎn)換為字符串。
   • String(String string)：復(fù)制字符串。

2. 常用方法：

   • char charAt(int index)：返回指定索引的字符。
   • int compareTo(String string)：字典比較大小。
   • boolean contains(String string)：判斷是否包含指定字符串。
   • boolean endsWith(String string)：判斷是否以指定字符串結(jié)尾。
   • boolean startsWith(String prefix)：判斷是否以指定前綴開頭。
   • boolean equals(Object anObject)：比較字符串內(nèi)容。
   • boolean equalsIgnoreCase(String anotherString)：忽略大小寫比較。
   • byte[] getBytes()：將字符串轉(zhuǎn)換為字節(jié)數(shù)組。
   • int indexOf(String str)：返回子字符串第一次出現(xiàn)的索引。
   • int lastIndexOf(String str)：返回子字符串最后一次出現(xiàn)的索引。
   • boolean isEmpty()：判斷字符串是否為空。
   • String replace(CharSequence target, CharSequence replacement)：替換字符串。
   • String substring(int beginIndex)：截取字符串。
   • char[] toCharArray()：將字符串轉(zhuǎn)換為字符數(shù)組。
   • String toLowerCase()：將字符串轉(zhuǎn)換為小寫。
   • String toUpperCase()：將字符串轉(zhuǎn)換為大寫。
   • String[] split(String regex)：按正則表達(dá)式拆分字符串。
   • String trim()：去除前后空白。
   • static String valueOf()：將其他類型轉(zhuǎn)換為字符串。

StringBuffer與StringBuilder

1. StringBuffer：

   • 線程安全，適用于多線程環(huán)境。
   • 常用方法：append()、reverse()。

2. StringBuilder：

   • 非線程安全，性能優(yōu)于StringBuffer。

包裝類

包裝類用于將基本數(shù)據(jù)類型轉(zhuǎn)換為對(duì)象：

1. 常用包裝類：
   • Integer、Character等。
2. 常用方法：
   • int intValue()：拆箱，將包裝類轉(zhuǎn)換為基本類型。
   • static int parseInt(String s)：將字符串轉(zhuǎn)換為整數(shù)。

日期相關(guān)類

1. java.util.Date：

   • 表示日期和時(shí)間。

2. SimpleDateFormat：

   • 用于格式化日期。
   • 常用方法：format()、parse()。

數(shù)字相關(guān)類

1. DecimalFormat：

   • 用于格式化數(shù)字。

2. BigDecimal：

   • 用于高精度計(jì)算，適用于財(cái)務(wù)數(shù)據(jù)。

3. Random：

   • 用于生成隨機(jī)數(shù)。

枚舉（Enum）

枚舉是一種特殊的類，用于定義一組常量：

enum Season {
    SPRING, SUMMER, AUTUMN, WINTER
}

內(nèi)部類

1. 成員內(nèi)部類：

   • 定義在類中，可以訪問(wèn)外部類的所有成員。

2. 局部?jī)?nèi)部類：

   • 定義在方法中，只能在該方法內(nèi)訪問(wèn)。

3. 靜態(tài)內(nèi)部類：

   • 使用static修飾，只能訪問(wèn)外部類的靜態(tài)成員。

4. 匿名內(nèi)部類：

   • 沒(méi)有名稱的內(nèi)部類，通常用于實(shí)現(xiàn)接口或抽象類。

總結(jié)

• 源碼是理解程序的基礎(chǔ)，字節(jié)碼是程序運(yùn)行的關(guān)鍵，幫助文檔是開發(fā)的指南。
• Object是Java的根類，提供了對(duì)象的基本操作。
• System類提供了系統(tǒng)級(jí)別的操作，如垃圾回收、時(shí)間獲取等。
• String類用于操作字符串，提供了豐富的構(gòu)造方法和方法。
• StringBuffer和StringBuilder用于字符串的拼接和修改，前者線程安全，后者性能更優(yōu)。
• 包裝類用于將基本數(shù)據(jù)類型轉(zhuǎn)換為對(duì)象。
• 日期相關(guān)類用于處理日期和時(shí)間。
• 內(nèi)部類提供了更靈活的代碼組織方式。

八、數(shù)組

一維數(shù)組

1. 定義:

   • 數(shù)組是引用數(shù)據(jù)類型，存儲(chǔ)在堆內(nèi)存中。
   • 可以存儲(chǔ)各種數(shù)據(jù)類型，但不能直接存儲(chǔ)對(duì)象，存儲(chǔ)的是對(duì)象的引用（內(nèi)存地址）。

2. 特點(diǎn):

   • 數(shù)組元素類型統(tǒng)一，最后一個(gè)下標(biāo)為 length - 1。
   • 帶有 length 屬性，用于獲取數(shù)組長(zhǎng)度。

3. 優(yōu)點(diǎn):

   • 查詢、查找、檢索某個(gè)下標(biāo)元素效率極高（內(nèi)存連續(xù)，類型相同）。

4. 缺點(diǎn):

   • 隨機(jī)增刪元素效率較低。
   • 不能存儲(chǔ)大數(shù)據(jù)量。

5. 定義與初始化:

   • 靜態(tài)初始化:

     數(shù)據(jù)類型[] 數(shù)組名 = {元素1, 元素2, ...};
     

   • 動(dòng)態(tài)初始化:

     數(shù)據(jù)類型[] 數(shù)組名 = new 數(shù)據(jù)類型[長(zhǎng)度];
     

6. 賦值:

   數(shù)組名[下標(biāo)] = 值;
   

7. 遍歷:

   • 使用 for 循環(huán)或增強(qiáng) for 循環(huán)：

     for (int i = 0; i < 數(shù)組名.length; i++) {
         System.out.println(數(shù)組名[i]);
     }
     

8. 方法參數(shù):

   • 數(shù)組可以作為方法的參數(shù)：

     void 方法名(數(shù)據(jù)類型[] 數(shù)組名) {}
     

9. main 方法的數(shù)組參數(shù):

   • main 方法的參數(shù)是一個(gè)字符串?dāng)?shù)組，用于接收命令行參數(shù)：

     public static void main(String[] args) {}
     

10. 存儲(chǔ)對(duì)象:

    • 數(shù)組可以存儲(chǔ)對(duì)象的引用：

      類名[] 數(shù)組名 = new 類名[長(zhǎng)度];
      數(shù)組名[0] = new 類名();
      

11. 數(shù)組擴(kuò)容:

    • 新建一個(gè)大數(shù)組，然后將原數(shù)組拷貝過(guò)去：

      int[] newArray = new int[原數(shù)組.length * 2];
      System.arraycopy(原數(shù)組, 0, newArray, 0, 原數(shù)組.length);
      

12. 數(shù)組拷貝:

    • 使用 System.arraycopy 方法：

      System.arraycopy(原數(shù)組, 原起點(diǎn), 目標(biāo)數(shù)組, 目標(biāo)下標(biāo), 長(zhǎng)度);
      

二維數(shù)組

1. 定義:

   • 二維數(shù)組是數(shù)組的數(shù)組，可以看作是一個(gè)表格。

2. 語(yǔ)法:

   數(shù)據(jù)類型[][] 數(shù)組名 = new 數(shù)據(jù)類型[行數(shù)][列數(shù)];
   

3. 初始化:

   • 靜態(tài)初始化:

     數(shù)據(jù)類型[][] 數(shù)組名 = {{元素1, 元素2}, {元素3, 元素4}};
     

   • 動(dòng)態(tài)初始化:

     數(shù)據(jù)類型[][] 數(shù)組名 = new 數(shù)據(jù)類型[行數(shù)][列數(shù)];
     

4. 遍歷:

   • 使用嵌套 for 循環(huán)：

     for (int i = 0; i < 數(shù)組名.length; i++) {
         for (int j = 0; j < 數(shù)組名[i].length; j++) {
             System.out.println(數(shù)組名[i][j]);
         }
     }
     

總結(jié)

1. 一維數(shù)組:

   • 適用于存儲(chǔ)一組相同類型的數(shù)據(jù)。
   • 查詢效率高，增刪效率低。
   • 可以通過(guò) length 屬性獲取長(zhǎng)度。
   • 支持靜態(tài)初始化和動(dòng)態(tài)初始化。

2. 二維數(shù)組:

   • 適用于存儲(chǔ)表格型數(shù)據(jù)。
   • 可以看作是一維數(shù)組的數(shù)組。
   • 支持靜態(tài)初始化和動(dòng)態(tài)初始化。

3. 數(shù)組的優(yōu)缺點(diǎn):

   • 優(yōu)點(diǎn)：查詢效率高，內(nèi)存連續(xù)。
   • 缺點(diǎn)：增刪效率低，不能存儲(chǔ)大數(shù)據(jù)量。

4. 數(shù)組的應(yīng)用場(chǎng)景:

   • 存儲(chǔ)一組固定長(zhǎng)度的數(shù)據(jù)。
   • 存儲(chǔ)對(duì)象引用。
   • 存儲(chǔ)表格型數(shù)據(jù)（二維數(shù)組）。

示例

1. 一維數(shù)組:

   int[] arr = {1, 2, 3, 4, 5};
   for (int i = 0; i < arr.length; i++) {
       System.out.println(arr[i]);
   }
   

2. 二維數(shù)組:

   int[][] arr = {{1, 2}, {3, 4}};
   for (int i = 0; i < arr.length; i++) {
       for (int j = 0; j < arr[i].length; j++) {
           System.out.println(arr[i][j]);
       }
   }
   

3. 數(shù)組存儲(chǔ)對(duì)象:

   Animal[] animals = new Animal[2];
   animals[0] = new Cat();
   animals[1] = new Dog();
   

4. 數(shù)組擴(kuò)容:

   int[] src = {1, 2, 3};
   int[] dest = new int[src.length * 2];
   System.arraycopy(src, 0, dest, 0, src.length);
   

通過(guò)合理使用數(shù)組，可以高效地存儲(chǔ)和操作數(shù)據(jù)，但需要注意其增刪效率較低的缺點(diǎn)。

九、算法

以下是常見(jiàn) 排序算法 和 查找算法 的思想總結(jié)，并附帶 Java 實(shí)例：

排序算法

1. 冒泡排序（Bubble Sort）:

   • 思想：重復(fù)遍歷數(shù)組，每次比較相鄰元素，如果順序錯(cuò)誤則交換，直到?jīng)]有需要交換的元素。

   • 時(shí)間復(fù)雜度：O(n²)。

   • Java 實(shí)現(xiàn):

     public static void bubbleSort(int[] arr) {
         for (int i = 0; i < arr.length - 1; i++) {
             for (int j = 0; j < arr.length - 1 - i; j++) {
                 if (arr[j] > arr[j + 1]) {
                     int temp = arr[j];
                     arr[j] = arr[j + 1];
                     arr[j + 1] = temp;
                 }
             }
         }
     }
     

2. 選擇排序（Selection Sort）:

   • 思想：每次從未排序部分選擇最小元素，放到已排序部分的末尾。

   • 時(shí)間復(fù)雜度：O(n²)。

   • Java 實(shí)現(xiàn):

     public static void selectionSort(int[] arr) {
         for (int i = 0; i < arr.length - 1; i++) {
             int minIndex = i;
             for (int j = i + 1; j < arr.length; j++) {
                 if (arr[j] < arr[minIndex]) {
                     minIndex = j;
                 }
             }
             int temp = arr[i];
             arr[i] = arr[minIndex];
             arr[minIndex] = temp;
         }
     }
     

3. 插入排序（Insertion Sort）:

   • 思想：將未排序部分的元素逐個(gè)插入到已排序部分的正確位置。

   • 時(shí)間復(fù)雜度：O(n²)。

   • Java 實(shí)現(xiàn):

     public static void insertionSort(int[] arr) {
         for (int i = 1; i < arr.length; i++) {
             int key = arr[i];
             int j = i - 1;
             while (j >= 0 && arr[j] > key) {
                 arr[j + 1] = arr[j];
                 j--;
             }
             arr[j + 1] = key;
         }
     }
     

4. 快速排序（Quick Sort）:

   • 思想：選擇一個(gè)基準(zhǔn)元素，將數(shù)組分為兩部分，左邊小于基準(zhǔn)，右邊大于基準(zhǔn)，遞歸排序。

   • 時(shí)間復(fù)雜度：O(n log n)。

   • Java 實(shí)現(xiàn):

     public static void quickSort(int[] arr, int low, int high) {
         if (low < high) {
             int pivot = partition(arr, low, high);
             quickSort(arr, low, pivot - 1);
             quickSort(arr, pivot + 1, high);
         }
     }
     
     private static int partition(int[] arr, int low, int high) {
         int pivot = arr[high];
         int i = low - 1;
         for (int j = low; j < high; j++) {
             if (arr[j] < pivot) {
                 i++;
                 int temp = arr[i];
                 arr[i] = arr[j];
                 arr[j] = temp;
             }
         }
         int temp = arr[i + 1];
         arr[i + 1] = arr[high];
         arr[high] = temp;
         return i + 1;
     }
     

5. 歸并排序（Merge Sort）:

   • 思想：將數(shù)組分成兩半，分別排序，然后合并。

   • 時(shí)間復(fù)雜度：O(n log n)。

   • Java 實(shí)現(xiàn):

     public static void mergeSort(int[] arr, int left, int right) {
         if (left < right) {
             int mid = (left + right) / 2;
             mergeSort(arr, left, mid);
             mergeSort(arr, mid + 1, right);
             merge(arr, left, mid, right);
         }
     }
     
     private static void merge(int[] arr, int left, int mid, int right) {
         int[] temp = new int[right - left + 1];
         int i = left, j = mid + 1, k = 0;
         while (i <= mid && j <= right) {
             if (arr[i] <= arr[j]) {
                 temp[k++] = arr[i++];
             } else {
                 temp[k++] = arr[j++];
             }
         }
         while (i <= mid) {
             temp[k++] = arr[i++];
         }
         while (j <= right) {
             temp[k++] = arr[j++];
         }
         for (int p = 0; p < temp.length; p++) {
             arr[left + p] = temp[p];
         }
     }
     

查找算法

1. 線性查找（Linear Search）:

   • 思想：從頭到尾遍歷數(shù)組，逐個(gè)比較，找到目標(biāo)元素。

   • 時(shí)間復(fù)雜度：O(n)。

   • Java 實(shí)現(xiàn):

     public static int linearSearch(int[] arr, int target) {
         for (int i = 0; i < arr.length; i++) {
             if (arr[i] == target) {
                 return i;
             }
         }
         return -1;
     }
     

2. 二分查找（Binary Search）:

   • 思想：在有序數(shù)組中，每次取中間元素與目標(biāo)比較，縮小查找范圍。

   • 時(shí)間復(fù)雜度：O(log n)。

   • Java 實(shí)現(xiàn):

     public static int binarySearch(int[] arr, int target) {
         int left = 0, right = arr.length - 1;
         while (left <= right) {
             int mid = (left + right) / 2;
             if (arr[mid] == target) {
                 return mid;
             } else if (arr[mid] < target) {
                 left = mid + 1;
             } else {
                 right = mid - 1;
             }
         }
         return -1;
     }
     

總結(jié)

1. 排序算法:

   • 冒泡排序：簡(jiǎn)單但效率低，適合小規(guī)模數(shù)據(jù)。
   • 選擇排序：每次選擇最小元素，適合小規(guī)模數(shù)據(jù)。
   • 插入排序：適合部分有序的數(shù)據(jù)。
   • 快速排序：高效，適合大規(guī)模數(shù)據(jù)。
   • 歸并排序：穩(wěn)定且高效，適合大規(guī)模數(shù)據(jù)。

2. 查找算法:

   • 線性查找：適合無(wú)序數(shù)據(jù)。
   • 二分查找：適合有序數(shù)據(jù)，效率高。

3. 選擇依據(jù):

   • 數(shù)據(jù)規(guī)模、是否有序、穩(wěn)定性要求等。

示例

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        bubbleSort(arr);
        System.out.println("冒泡排序結(jié)果: " + Arrays.toString(arr));

        int[] arr2 = {5, 3, 8, 4, 2};
        quickSort(arr2, 0, arr2.length - 1);
        System.out.println("快速排序結(jié)果: " + Arrays.toString(arr2));

        int target = 4;
        int index = binarySearch(arr2, target);
        System.out.println("二分查找結(jié)果: " + (index != -1 ? "找到，下標(biāo)為 " + index : "未找到"));
    }
}

輸出：

冒泡排序結(jié)果: [2, 3, 4, 5, 8]
快速排序結(jié)果: [2, 3, 4, 5, 8]
二分查找結(jié)果: 找到，下標(biāo)為 2

通過(guò)合理選擇排序和查找算法，可以高效地處理數(shù)據(jù)。

十、異常

1. 異常的基本概念

• 異常在 Java 中以類的方式存在，每個(gè)異常類都可以創(chuàng)建異常對(duì)象。
• 方法覆蓋規(guī)則：子類重寫父類方法時(shí)，不能拋出比父類方法更高的異常（運(yùn)行時(shí)異常 RuntimeException 除外）。
• 異常的分類：
  • java.lang.Throwable：異常的父類，有兩個(gè)子類：
    • Error：錯(cuò)誤，通常是系統(tǒng)級(jí)錯(cuò)誤（如 OutOfMemoryError），不可處理，只能退出程序。
    • Exception：異常，所有異常都是在運(yùn)行階段發(fā)生的。
      • Exception 的直接子類：編譯時(shí)異常（受檢異常 CheckedException），需要在編寫程序時(shí)預(yù)處理。
      • RuntimeException：運(yùn)行時(shí)異常，通常由程序邏輯錯(cuò)誤引起，不需要顯式處理。

2. 常見(jiàn)運(yùn)行時(shí)異常

• NullPointerException：空指針異常，嘗試訪問(wèn) null 對(duì)象的成員。
• ArrayIndexOutOfBoundsException：數(shù)組下標(biāo)越界異常。
• ClassCastException：類型轉(zhuǎn)換異常，嘗試將對(duì)象強(qiáng)制轉(zhuǎn)換為不兼容的類型。
• NumberFormatException：數(shù)字轉(zhuǎn)換異常，嘗試將非數(shù)字字符串轉(zhuǎn)換為數(shù)字。

3. 異常處理方式

1. throws 關(guān)鍵字：

   • 在方法聲明位置使用，將異常拋給調(diào)用者處理。

   • 示例：

     public void readFile() throws IOException {
         // 可能拋出 IOException 的代碼
     }
     

2. try-catch-finally 語(yǔ)句：

   • 捕獲并處理異常。

   • 示例：

     try {
         // 可能拋出異常的代碼
     } catch (NullPointerException e) {
         System.out.println("空指針異常: " + e.getMessage());
     } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("數(shù)組下標(biāo)越界: " + e.getMessage());
     } finally {
         // 無(wú)論是否發(fā)生異常，都會(huì)執(zhí)行的代碼
         System.out.println("finally 塊執(zhí)行");
     }
     

4. 常用異常方法

• getMessage()：獲取異常的簡(jiǎn)單描述信息（通常是構(gòu)造方法的參數(shù)）。
• printStackTrace()：打印異常的堆棧追蹤信息（異步線程中常用）。

5. 自定義異常

• 步驟：

  1. 編寫一個(gè)類繼承 Exception（受檢異常）或 RuntimeException（運(yùn)行時(shí)異常）。
  2. 提供兩個(gè)構(gòu)造方法：一個(gè)無(wú)參，一個(gè)有參。
  3. 使用 throw 手動(dòng)拋出異常。

• 示例：

  // 自定義異常類
  public class MyException extends Exception {
      public MyException() {
          super();
      }
  
      public MyException(String message) {
          super(message);
      }
  }
  
  // 使用自定義異常
  public class Test {
      public static void main(String[] args) {
          try {
              throw new MyException("自定義異常發(fā)生");
          } catch (MyException e) {
              System.out.println(e.getMessage());
          }
      }
  }
  

6. 異常處理的最佳實(shí)踐

• 明確異常類型：捕獲具體異常，而不是直接捕獲 Exception。
• 合理使用 finally：用于釋放資源（如關(guān)閉文件、數(shù)據(jù)庫(kù)連接等）。
• 避免空指針異常：在使用對(duì)象前進(jìn)行 null 檢查。
• 日志記錄：使用日志框架（如 Log4j 或 SLF4J）記錄異常信息，便于排查問(wèn)題。

總結(jié)

• 異常分類：Error 和 Exception，其中 Exception 分為編譯時(shí)異常和運(yùn)行時(shí)異常。
• 處理方式：throws 拋給調(diào)用者，try-catch-finally 捕獲并處理。
• 自定義異常：繼承 Exception 或 RuntimeException，提供構(gòu)造方法，使用 throw 拋出。
• 最佳實(shí)踐：明確異常類型，合理使用 finally，避免空指針異常，記錄日志。

十一、I/O

I/O（輸入/輸出）概述

I/O（Input/Output）是指應(yīng)用程序與外部設(shè)備（如磁盤、網(wǎng)絡(luò)、鍵盤、顯示器等）之間的數(shù)據(jù)交互。Java通過(guò)java.io包提供了豐富的I/O類庫(kù)，支持文件操作、字節(jié)流、字符流等功能。

File類

File類是java.io包中唯一代表磁盤文件本身的對(duì)象，用于操作文件和目錄。

構(gòu)造方法

1. File(String path)：

   • 根據(jù)路徑創(chuàng)建File對(duì)象。

2. File(String parent, String child)：

   • 根據(jù)父路徑和子路徑（包括文件名）創(chuàng)建File對(duì)象。

3. File(File parent, String child)：

   • 根據(jù)File對(duì)象表示的父路徑和子路徑創(chuàng)建File對(duì)象。

注意：路徑分隔符可以使用\\（Windows）或/（Unix/Linux）。

常用方法

1. boolean exists()：

   • 判斷文件或目錄是否存在。

2. boolean delete()：

   • 刪除文件或目錄。

3. boolean createNewFile()：

   • 如果文件不存在，則創(chuàng)建一個(gè)新文件。

4. String getName()：

   • 返回文件或目錄的名稱。

5. String getPath()：

   • 返回文件或目錄的路徑。

6. String getAbsolutePath()：

   • 返回文件或目錄的絕對(duì)路徑。

7. boolean canRead()：

   • 判斷文件是否可讀。

8. boolean canWrite()：

   • 判斷文件是否可寫。

9. boolean isFile()：

   • 判斷是否為文件。

10. boolean isDirectory()：

    • 判斷是否為目錄。

11. long length()：

    • 返回文件內(nèi)容的長(zhǎng)度（字節(jié)數(shù)）。

12. String[] list()：

    • 返回目錄內(nèi)所有文件和子目錄的名稱。

13. File[] listFiles()：

    • 返回目錄內(nèi)所有文件和子目錄的File對(duì)象。

14. createTempFile(String prefix, String suffix)：

    • 創(chuàng)建臨時(shí)文件。

15. deleteOnExit()：

    • JVM退出時(shí)自動(dòng)刪除文件。

字節(jié)流

字節(jié)流用于處理二進(jìn)制數(shù)據(jù)（如圖片、音頻、視頻等），以字節(jié)為單位進(jìn)行讀寫操作。

字節(jié)輸入流（InputStream）

InputStream是字節(jié)輸入流的抽象類，用于從源（如文件、網(wǎng)絡(luò)等）讀取數(shù)據(jù)。

常用方法：

1. int read()：

   • 逐個(gè)字節(jié)讀取，返回讀取的字節(jié)值（0-255），如果到達(dá)流末尾則返回-1。

2. int read(byte[] b)：

   • 將數(shù)據(jù)讀取到字節(jié)數(shù)組b中，返回實(shí)際讀取的字節(jié)數(shù)。

3. int read(byte[] b, int off, int len)：

   • 從偏移量off開始，讀取len個(gè)字節(jié)到數(shù)組b中，返回實(shí)際讀取的字節(jié)數(shù)。

4. void close()：

   • 關(guān)閉流，釋放資源。

字節(jié)輸出流（OutputStream）

OutputStream是字節(jié)輸出流的抽象類，用于將數(shù)據(jù)寫入目標(biāo)（如文件、網(wǎng)絡(luò)等）。

常用方法：

1. void write(int b)：

   • 逐個(gè)字節(jié)寫入。

2. void write(byte[] b)：

   • 將字節(jié)數(shù)組b中的數(shù)據(jù)寫入。

3. void write(byte[] b, int off, int len)：

   • 從偏移量off開始，寫入len個(gè)字節(jié)。

4. void flush()：

   • 強(qiáng)制將緩沖區(qū)中的數(shù)據(jù)寫入目標(biāo)。

5. void close()：

   • 關(guān)閉流，釋放資源。

具體實(shí)現(xiàn)類

1. FileInputStream：

   • 用于從文件中讀取字節(jié)數(shù)據(jù)。

2. FileOutputStream：

   • 用于將字節(jié)數(shù)據(jù)寫入文件。

拓展總結(jié)

1. 文件操作：

   • 使用File類可以創(chuàng)建、刪除、重命名文件，判斷文件是否存在，查詢文件屬性等。

2. 字節(jié)流：

   • 字節(jié)流適用于處理二進(jìn)制數(shù)據(jù)，InputStream和OutputStream是字節(jié)流的抽象基類。
   • FileInputStream和FileOutputStream是常用的字節(jié)流實(shí)現(xiàn)類，用于文件的讀寫操作。

3. 流的使用注意事項(xiàng)：

   • 使用流時(shí)，務(wù)必在操作完成后調(diào)用close()方法關(guān)閉流，釋放系統(tǒng)資源。
   • 對(duì)于輸出流，可以調(diào)用flush()方法強(qiáng)制將緩沖區(qū)中的數(shù)據(jù)寫入目標(biāo)。

4. 臨時(shí)文件：

   • 使用createTempFile()方法可以創(chuàng)建臨時(shí)文件，deleteOnExit()方法可以確保JVM退出時(shí)自動(dòng)刪除臨時(shí)文件。

5. 路徑處理：

   • 路徑分隔符可以使用\\（Windows）或/（Unix/Linux），Java會(huì)自動(dòng)處理。

6. 性能優(yōu)化：

   • 對(duì)于大文件的讀寫，建議使用緩沖區(qū)（如BufferedInputStream和BufferedOutputStream）來(lái)提高性能。

示例代碼

文件操作

File file = new File("test.txt");
if (!file.exists()) {
    file.createNewFile(); // 創(chuàng)建文件
}
System.out.println("文件名稱: " + file.getName());
System.out.println("文件路徑: " + file.getAbsolutePath());
file.delete(); // 刪除文件

字節(jié)流讀寫

// 寫入文件
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
    fos.write("Hello, World!".getBytes());
    fos.flush();
}

// 讀取文件
try (FileInputStream fis = new FileInputStream("output.txt")) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = fis.read(buffer)) != -1) {
        System.out.println(new String(buffer, 0, len));
    }
}

通過(guò)掌握這些核心概念和類庫(kù)，可以高效地處理文件操作和字節(jié)流讀寫。

字符流總結(jié)

字符流是Java I/O中用于處理文本數(shù)據(jù)的流，它以字符為單位進(jìn)行讀寫操作。與字節(jié)流不同，字符流專門用于處理字符數(shù)據(jù)（如文本文件），并且支持字符編碼（如UTF-8、GBK等），能夠正確處理多字節(jié)字符。

字符流概述

字符流的核心類是Reader和Writer，它們分別是字符輸入流和字符輸出流的抽象基類。字符流的主要特點(diǎn)包括：

1. 以字符為單位：
   • 字符流以字符為單位讀寫數(shù)據(jù)，適合處理文本文件。
2. 支持字符編碼：
   • 字符流可以正確處理字符編碼，避免亂碼問(wèn)題。
3. 高效讀寫：
   • 字符流通常與緩沖區(qū)結(jié)合使用（如BufferedReader和BufferedWriter），提高讀寫效率。

字符輸入流（Reader）

Reader是字符輸入流的抽象類，用于從源（如文件、字符串等）讀取字符數(shù)據(jù)。

常用方法

1. int read()：

   • 讀取單個(gè)字符，返回字符的Unicode值（0-65535），如果到達(dá)流末尾則返回-1。

2. int read(char[] cbuf)：

   • 將字符數(shù)據(jù)讀取到字符數(shù)組cbuf中，返回實(shí)際讀取的字符數(shù)。

3. int read(char[] cbuf, int off, int len)：

   • 從偏移量off開始，讀取len個(gè)字符到數(shù)組cbuf中，返回實(shí)際讀取的字符數(shù)。

4. void close()：

   • 關(guān)閉流，釋放資源。

具體實(shí)現(xiàn)類

1. FileReader：

   • 用于從文件中讀取字符數(shù)據(jù)。

2. BufferedReader：

   • 帶有緩沖區(qū)的字符輸入流，提供readLine()方法逐行讀取文本。

3. InputStreamReader：

   • 將字節(jié)流轉(zhuǎn)換為字符流，支持指定字符編碼。

字符輸出流（Writer）

Writer是字符輸出流的抽象類，用于將字符數(shù)據(jù)寫入目標(biāo)（如文件、控制臺(tái)等）。

常用方法

1. void write(int c)：

   • 寫入單個(gè)字符。

2. void write(char[] cbuf)：

   • 寫入字符數(shù)組cbuf中的數(shù)據(jù)。

3. void write(char[] cbuf, int off, int len)：

   • 從偏移量off開始，寫入len個(gè)字符。

4. void write(String str)：

   • 寫入字符串str。

5. void write(String str, int off, int len)：

   • 從偏移量off開始，寫入len個(gè)字符。

6. void flush()：

   • 強(qiáng)制將緩沖區(qū)中的數(shù)據(jù)寫入目標(biāo)。

7. void close()：

   • 關(guān)閉流，釋放資源。

具體實(shí)現(xiàn)類

1. FileWriter：

   • 用于將字符數(shù)據(jù)寫入文件。

2. BufferedWriter：

   • 帶有緩沖區(qū)的字符輸出流，提供newLine()方法寫入換行符。

3. OutputStreamWriter：

   • 將字節(jié)流轉(zhuǎn)換為字符流，支持指定字符編碼。

字符流與字節(jié)流的區(qū)別

1. 單位不同：

   • 字節(jié)流以字節(jié)為單位，適合處理二進(jìn)制數(shù)據(jù)。
   • 字符流以字符為單位，適合處理文本數(shù)據(jù)。

2. 編碼支持：

   • 字節(jié)流不涉及字符編碼，直接處理字節(jié)數(shù)據(jù)。
   • 字符流支持字符編碼，能夠正確處理多字節(jié)字符。

3. 性能優(yōu)化：

   • 字符流通常與緩沖區(qū)結(jié)合使用，提高讀寫效率。

示例代碼

字符流讀寫文件

// 寫入文件
try (FileWriter fw = new FileWriter("output.txt");
     BufferedWriter bw = new BufferedWriter(fw)) {
    bw.write("Hello, World!");
    bw.newLine(); // 寫入換行符
    bw.write("This is a test.");
}

// 讀取文件
try (FileReader fr = new FileReader("output.txt");
     BufferedReader br = new BufferedReader(fr)) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

使用指定編碼讀寫文件

// 寫入文件（指定編碼為UTF-8）
try (OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("output.txt"), "UTF-8");
     BufferedWriter bw = new BufferedWriter(osw)) {
    bw.write("你好，世界！");
}

// 讀取文件（指定編碼為UTF-8）
try (InputStreamReader isr = new InputStreamReader(new FileInputStream("output.txt"), "UTF-8");
     BufferedReader br = new BufferedReader(isr)) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

總結(jié)

1. 字符流適用場(chǎng)景：

   • 處理文本文件、字符串等字符數(shù)據(jù)。

2. 核心類：

   • Reader和Writer是字符流的抽象基類。
   • FileReader、BufferedReader、FileWriter、BufferedWriter是常用的實(shí)現(xiàn)類。

3. 字符編碼：

   • 使用InputStreamReader和OutputStreamWriter可以指定字符編碼，避免亂碼問(wèn)題。

4. 性能優(yōu)化：

   • 使用BufferedReader和BufferedWriter可以提高讀寫效率。

5. 流關(guān)閉：

   • 使用try-with-resources語(yǔ)法確保流被正確關(guān)閉，釋放資源。

通過(guò)掌握字符流的核心概念和類庫(kù)，可以高效地處理文本數(shù)據(jù)的讀寫操作。

十二、集合

集合是Java中用于存儲(chǔ)和管理一組對(duì)象的容器。它提供了一種更靈活、更高效的方式來(lái)操作數(shù)據(jù)集合。以下是集合的核心概念和總結(jié)：

集合的特點(diǎn)

1. 容器性質(zhì)：

   • 集合是一個(gè)容器，可以容納其他類型的數(shù)據(jù)。
   • 集合不能直接存儲(chǔ)基本數(shù)據(jù)類型（如int、char等），也不能直接存儲(chǔ)對(duì)象，存儲(chǔ)的是Java對(duì)象的內(nèi)存地址（引用）。

2. 數(shù)據(jù)結(jié)構(gòu)：

   • 不同的集合對(duì)應(yīng)不同的數(shù)據(jù)結(jié)構(gòu)（如數(shù)組、鏈表、哈希表、二叉樹等）。
   • 使用不同的集合等同于使用了不同的數(shù)據(jù)結(jié)構(gòu)。

3. 包位置：

   • 所有的集合類都位于java.util包中。

集合的層次結(jié)構(gòu)

1. 超級(jí)父接口：Iterable<T>：

   • 所有集合都是可迭代的，即可以通過(guò)迭代器遍歷集合中的元素。
   • 方法：Iterator<T> iterator()：返回集合的迭代器。

2. 單個(gè)元素集合的父接口：Collection<E>：

   • 表示存儲(chǔ)單個(gè)元素的集合的超級(jí)接口。
   • 子接口包括：List、Set、Queue等。

3. 鍵值對(duì)集合的父接口：Map<K,V>：

   • 表示存儲(chǔ)鍵值對(duì)的集合，獨(dú)立于Collection體系。

集合的實(shí)現(xiàn)類總結(jié)

1.List接口的實(shí)現(xiàn)類：

• ArrayList：
  • 底層是數(shù)組，查詢快，增刪慢。
  • 非線程安全。
• LinkedList：
  • 底層是雙向鏈表，增刪快，查詢慢。
  • 非線程安全。
• Vector：
  • 底層是數(shù)組，線程安全，但效率較低，使用較少。

2.Set接口的實(shí)現(xiàn)類：

• HashSet：
  • 底層是HashMap，元素存儲(chǔ)在HashMap的key部分。
  • 無(wú)序且不允許重復(fù)。
• TreeSet：
  • 底層是TreeMap，元素存儲(chǔ)在TreeMap的key部分。
  • 元素自動(dòng)按大小順序排序。

3.Map接口的實(shí)現(xiàn)類：

• HashMap：
  • 底層是哈希表，非線程安全。
  • 允許null鍵和null值。
• Hashtable：
  • 底層是哈希表，線程安全，但效率較低，使用較少。
  • 不允許null鍵和null值。
• Properties：
  • 底層是哈希表，線程安全。
  • key和value只能存儲(chǔ)字符串（String）。
• TreeMap：
  • 底層是二叉樹。
  • key自動(dòng)按照大小順序排序。

集合的選擇

1. 需要存儲(chǔ)單個(gè)元素：

   • 如果需要有序且允許重復(fù)，使用List：
     • 查詢多，增刪少：ArrayList。
     • 增刪多，查詢少：LinkedList。
   • 如果不需要重復(fù)元素，使用Set：
     • 無(wú)序：HashSet。
     • 有序：TreeSet。

2. 需要存儲(chǔ)鍵值對(duì)：

   • 非線程安全：HashMap。
   • 線程安全：Hashtable或Properties。
   • 需要排序：TreeMap。

3. 線程安全：

   • 如果需要線程安全，可以使用Vector、Hashtable或Properties，但效率較低。
   • 推薦使用Collections.synchronizedList()或ConcurrentHashMap等并發(fā)集合。

總結(jié)

1. 集合的核心：

   • 集合是存儲(chǔ)和管理一組對(duì)象的容器，存儲(chǔ)的是對(duì)象的內(nèi)存地址。
   • 不同的集合對(duì)應(yīng)不同的數(shù)據(jù)結(jié)構(gòu)，選擇合適的集合可以提高程序效率。

2. 常用集合：

   • List：有序且允許重復(fù)，常用ArrayList和LinkedList。
   • Set：無(wú)序且不允許重復(fù)，常用HashSet和TreeSet。
   • Map：存儲(chǔ)鍵值對(duì)，常用HashMap、TreeMap和Properties。

3. 線程安全：

   • 線程安全的集合有Vector、Hashtable和Properties，但效率較低。
   • 推薦使用并發(fā)集合（如ConcurrentHashMap）來(lái)實(shí)現(xiàn)線程安全。

通過(guò)掌握集合的核心概念和常用實(shí)現(xiàn)類，可以更高效地處理數(shù)據(jù)集合，并根據(jù)需求選擇合適的集合類型。

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

有序可重復(fù)

有序：存進(jìn)去的順序和取出的順序相同，每一個(gè)元素都有下標(biāo)

可重復(fù)：存進(jìn)去1，可以再存儲(chǔ)一個(gè)1

Set 集合存儲(chǔ)元素的特點(diǎn)（Map的Key）：

無(wú)序不可重復(fù)

無(wú)序：存進(jìn)去的順序和取出的順序不一定相同，另外 Set 集合中元素沒(méi)有下標(biāo)（哈希表的存儲(chǔ)）

不可重復(fù)：存進(jìn)去1，不能再存儲(chǔ)1了（哈希表的覆蓋）

SortedSet( SortedMap ）集合存儲(chǔ)元素特點(diǎn)：

首先是無(wú)序不可重復(fù)的，但是 SortedSet 集合中的元素是可排序的

無(wú)序：存進(jìn)去的順序和取出的順序不一定相同，另外 Set 集合中元素沒(méi)有下標(biāo)

不可重復(fù)：存進(jìn)去1，不能再存儲(chǔ)1了

可排序：可以按照大小順序排列。

Map 集合的 key ，就是一個(gè) Set 集合。

往 Set 集合中放數(shù)據(jù)，實(shí)際上放到了 Map 集合的 key 部分。

InterfaceCollection

沒(méi)有使用泛型前可以存儲(chǔ)Object的所有子類型

• Boolean add(E e) 添加元素
• Object[] toArray() 轉(zhuǎn)化成數(shù)組（使用不多）
• Int size() 返回此集合中元素的數(shù)目。
• Boolean contains(Object o) 如果此集合包含指定的元素（存放在集合中的類型，需要重寫equals方法）
• Void clear() 從此集合中刪除所有元素
• Boolean equals(Object o) 將指定的對(duì)象與此集合進(jìn)行比較以實(shí)現(xiàn)相等性（內(nèi)存地址）
• Boolean remove(Object o) 從此集合中刪除指定元素的單個(gè)實(shí)例
• Boolean isEmpty() 如果此集合不包含任何元素（判空）則返回。true

Iterator<E> iterator() ***：**不管存進(jìn)去什么，拿出來(lái)都是Object，取出來(lái)還是原類型

返回此集合中元素的迭代器**，Collection通用，Map集合不能用**

只要集合結(jié)構(gòu)發(fā)生改變迭代器一定要重新獲取

• default void forEachRemaining(Consumer<? super E> action) 對(duì)每個(gè)剩余元素執(zhí)行給定的操作，直到所有元素都已處理完畢或該操作引發(fā)異常。
• Boolean hasNext() 如果迭代具有更多元素，則返回。true
• Object next() 返回迭代中的下一個(gè)元素。（返回object）
• default void remove() 從基礎(chǔ)集合中刪除此迭代器返回的最后一個(gè)元素（可選操作）。

Interface List有序可重復(fù)，Collection子接口

• void add(int index, E element) 在此列表中的指定位置插入指定的元素
• E get(int index) 返回此列表中指定位置處的元素
• E set(int index, E element) 將此列表中指定位置的元素替換為指定的元素
• int indexOf(Object o) 返回此列表中指定元素的第一次出現(xiàn)的索引，如果此列表不包含該元素，則返回 -1
• int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出現(xiàn)的索引，如果此列表不包含該元素，則返回 -1。
• E remove(int index) 刪除此列表中指定位置的元素

Class ArrayList 非線程安全數(shù)組，初始化容量10，底層object數(shù)組

構(gòu)造方法：

• ArrayList() 構(gòu)造初始容量為 10 的空列表（底層先創(chuàng)建了一個(gè)長(zhǎng)度為0的數(shù)組，添加元素是初始化為10，自動(dòng)擴(kuò)容1.5倍）
• ArrayList(int initialCapacity) 構(gòu)造具有指定初始容量的空列表（建議提前估計(jì)，減少擴(kuò)容）
• ArrayList(Collection<? extends E> c) 構(gòu)造一個(gè)列表，其中包含指定集合的元素，并按集合的迭代器返回這些元素的順序排列。

方法：同List方法

Class LinkedList 雙向鏈表，隨機(jī)增刪效率高，檢索效率低

Class Vector 線程安全數(shù)組，默認(rèn)10，擴(kuò)容翻倍**（不經(jīng)常使用）**

轉(zhuǎn)換：使用集合工具類：java.util.Collections.synchronizedList(集合)

Interface Set無(wú)序不可重復(fù)存儲(chǔ)Map的Key

Class HashSet 哈希表（底層HashMap）

需要重寫hashCode和equals方法，其他方法參見(jiàn)HashMap

Interface SortedSet無(wú)序不可重復(fù)可排序

Class TreeSet 二叉樹（底層TreeMap Key部分）無(wú)序不可重復(fù)可排序

Key值自定義類需要實(shí)現(xiàn)java.long.Comparable接口或者創(chuàng)建比較器對(duì)象

class user implements Comparable<user>{      //自定義類需要實(shí)現(xiàn)接口
  int age;

  public user(int age) {
    this.age = age;
  }


 @Override
  public String toString() {
    return "user{" + "age=" + age + '}';
  }
  @Override         //重寫比較規(guī)則
  public int compareTo(user o) {
    return this.age-o.age;    //返回==0，value覆蓋，返回大于0 到右子樹，返回小于0到左子樹
  }
}

Interface Map<K,V>Map主接口（和Collection沒(méi)有繼承關(guān)系）

以Key和Value存儲(chǔ)數(shù)據(jù)都是引用數(shù)據(jù)類型，都存儲(chǔ)內(nèi)存地址，Key是主導(dǎo)

• V put(K key, V value) 添加鍵值對(duì)（Key元素需要重新hashCode和equals方法）（Key可以為空，只有一個(gè)）
• void clear() 清空Map集合
• V get(Object key) 通過(guò)key獲取value（key元素需要重新hashCode和equals方法）
• boolean containsKey(Object key) 判斷Map是否包含某個(gè)key（底層equals）
• boolean containsValue(Object value) 判斷Map是否包含某個(gè)value（底層equals）
• boolean isEmpty() 判斷Map集合元素個(gè)數(shù)是否為零
• Set<K> keySet() 獲取Map集合所有的Key（是個(gè)set集合）
• V remove(Object key) 通過(guò)key刪除鍵值對(duì)
• Collection<V> values() 獲取Map集合中鍵值對(duì)所有value（返回Collection）
• int size() 獲取Map集合所有的鍵值對(duì)個(gè)數(shù)

Set<Map.Entry<Integer,String>>set1=m.entrySet();       //使用方法
Iterator<Map.Entry<Integer,String>> it=set1.iterator(); //獲取迭代器
while (it.hasNext()) {
  Map.Entry<Integer, String> entry = it.next();
  System.out.println(entry);     //直接遍歷
  Integer key = entry.getKey();    //獲取鍵
  String value = entry.getValue();    //獲取值
  System.out.println(key + "=" + value);   //分開遍歷

for(Map.Entry<Integer,String> node:set1)   //效率較高，適合大數(shù)據(jù)，直接獲取
  System.out.println(node);     //組合遍歷

Class HashMap<K,V> 哈希表 非線程安全（初始化容量16[必須是2的倍數(shù)]，默認(rèn)加載因子0.75）

Key元素類型需要重新hashCode和equals方法

JDK8新特性：當(dāng)單向鏈表長(zhǎng)度超過(guò)8后數(shù)據(jù)結(jié)構(gòu)會(huì)變成紅黑樹數(shù)據(jù)結(jié)構(gòu)，當(dāng)紅黑樹小于6，會(huì)變回鏈表

構(gòu)造 函數(shù) 描述

• HashMap() 使用默認(rèn)初始容量 （16） ，默認(rèn)負(fù)載系數(shù) （0.75）
• HashMap(int initialCapacity) 指定的初始容量，默認(rèn)負(fù)載系數(shù) 初始容量必須是2的倍數(shù)：達(dá)到散列均勻，提高存取效率
• HashMap(int initialCapacity, float loadFactor) 指定初始容量和負(fù)載系數(shù)
• HashMap(Map<? extends K,? extends V> m)

Class Hashtable<K,V> 哈希表 線程安全（synchronized） Key不可以為空*（不常用）**

初始化容量11，默認(rèn)加載因子0.75f，擴(kuò)容：原容量*2+1

Class Properties 屬性類 繼承Hashtable類 僅支持String

• Object setProperty(String key, String value) 存
• String getProperty(String key) 取
• String getProperty(String key, String defaultValue) 當(dāng)key值為NULL時(shí),返回def的值；當(dāng)key值不為NULL時(shí),返回key的值

Interface SortedMap<K,V>

Class TreeMap<K,V> 二叉樹 可排序集合（中序遍歷）

Key值自定義類需要實(shí)現(xiàn)java.long.Comparable接口或者創(chuàng)建比較器對(duì)象（類或者匿名內(nèi)部類）

Class Collections 集合工具類

• synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（線程安全）映射。
• synchronizedList(List list) 返回由指定列表支持的同步（線程安全）列表。**
  **synchronizedCollection(Collection c) 返回由指定集合支持的同步（線程安全）集合
• sort(List list, Comparator<? super T> c) 根據(jù)指定比較器引發(fā)的順序?qū)χ付斜磉M(jìn)行排序。

十三、泛型

1. 泛型概述

• 引入時(shí)間：JDK 5.0 之后的新特性。

• 作用：

  • 統(tǒng)一集合中元素的類型，避免類型轉(zhuǎn)換錯(cuò)誤。
  • 只在程序編譯階段起作用，編譯后會(huì)進(jìn)行類型擦除（Type Erasure）。

• 語(yǔ)法：

  • 在創(chuàng)建對(duì)象時(shí)，前后兩段添加泛型類型。

  • 示例：

    List<String> list = new ArrayList<String>();
    

2. 泛型的優(yōu)點(diǎn)

• 類型安全：編譯時(shí)檢查類型，避免運(yùn)行時(shí)類型轉(zhuǎn)換錯(cuò)誤。
• 代碼復(fù)用：可以編寫通用的類和方法，適用于多種類型。
• 代碼簡(jiǎn)潔：減少?gòu)?qiáng)制類型轉(zhuǎn)換的代碼。

3. 泛型的缺點(diǎn)

• 導(dǎo)致集合存儲(chǔ)缺少多樣性：泛型限制了集合中元素的類型，無(wú)法存儲(chǔ)多種類型的對(duì)象。
• 類型擦除：泛型信息在編譯后會(huì)被擦除，運(yùn)行時(shí)無(wú)法獲取泛型的具體類型。

4. 自動(dòng)推斷機(jī)制（鉆石表達(dá)式）

• 引入時(shí)間：JDK 7 新特性。

• 作用：自動(dòng)推斷泛型類型，簡(jiǎn)化代碼。

• 語(yǔ)法：只寫前面的泛型類型，后面的泛型類型可以省略。

• 示例：

  List<String> list = new ArrayList<>();
  

5. 自定義泛型

• 泛型類：

  • 在定義類時(shí)添加 <T>，T 是類型參數(shù)。

  • 示例：

    public class Box<T> {
        private T value;
    
        public void setValue(T value) {
            this.value = value;
        }
    
        public T getValue() {
            return value;
        }
    }
    

  • 使用：

    Box<String> box = new Box<>();
    box.setValue("Hello");
    String value = box.getValue();
    

• 泛型方法：

  • 在定義方法時(shí)添加 <T>，T 是類型參數(shù)。

  • 示例：

    public <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
    

  • 使用：

    Integer[] intArray = {1, 2, 3};
    printArray(intArray);
    

6. 泛型的通配符

• <?>：表示任意類型。

• <? extends T>：表示 T 或其子類型（上界通配符）。

• <? super T>：表示 T 或其父類型（下界通配符）。

• 示例：

  public void printList(List<?> list) {
      for (Object element : list) {
          System.out.println(element);
      }
  }
  

7. 泛型的限制

• 不能使用基本類型：泛型類型必須是引用類型（如 Integer 而不是 int）。
• 不能創(chuàng)建泛型數(shù)組：例如 new T[10] 是非法的。
• 不能實(shí)例化泛型類型：例如 new T() 是非法的。

8. 泛型的應(yīng)用場(chǎng)景

• 集合框架：如 List<T>、Map<K, V> 等。
• 工具類：如 Comparator<T>、Comparable<T> 等。
• 自定義數(shù)據(jù)結(jié)構(gòu)：如棧、隊(duì)列、鏈表等。

總結(jié)與拓展

• 泛型的作用：統(tǒng)一集合中元素的類型，提高代碼的安全性和復(fù)用性。
• 自動(dòng)推斷機(jī)制：JDK 7 引入的鉆石表達(dá)式簡(jiǎn)化了泛型代碼。
• 自定義泛型：通過(guò)泛型類和泛型方法實(shí)現(xiàn)通用代碼。
• 通配符：<?>、<? extends T>、<? super T> 提供了更靈活的類型約束。
• 限制：泛型不能使用基本類型、不能創(chuàng)建泛型數(shù)組、不能實(shí)例化泛型類型。

十四、多線程

進(jìn)程是:一個(gè)應(yīng)用程序（1個(gè)進(jìn)程是一個(gè)軟件）

獨(dú)立性：系統(tǒng)分配資源和調(diào)度資源的獨(dú)立單位

動(dòng)態(tài)性：進(jìn)程實(shí)質(zhì)是程序的一次執(zhí)行過(guò)程，進(jìn)程是動(dòng)態(tài)產(chǎn)生，動(dòng)態(tài)消亡的

并發(fā)性：任何進(jìn)程都可以同其他進(jìn)程一起并發(fā)執(zhí)行

線程是：一個(gè)進(jìn)程中的執(zhí)行場(chǎng)景/執(zhí)行單元，是進(jìn)程中單個(gè)順序控制流，是一條執(zhí)行路徑。

并行：同一時(shí)刻，多個(gè)指令在多個(gè)CPU上同時(shí)執(zhí)行

并發(fā)：同一時(shí)刻，多個(gè)指令在單個(gè)CPU交替執(zhí)行

線程狀態(tài)轉(zhuǎn)換

1、新建狀態(tài)（New）：新創(chuàng)建了一個(gè)線程對(duì)象。

2、就緒狀態(tài)（Runnable）：線程對(duì)象創(chuàng)建后，其他線程調(diào)用了該對(duì)象的start()方法。該狀態(tài)的線程位于可運(yùn)行線程池中，變得可運(yùn)行，等待獲取CPU的使用權(quán)。

3、運(yùn)行狀態(tài)（Running）：就緒狀態(tài)的線程獲取了CPU，執(zhí)行程序代碼。

4、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因?yàn)槟撤N原因放棄CPU使用權(quán)，暫時(shí)停止運(yùn)行。直到線程進(jìn)入就緒狀態(tài)，才有機(jī)會(huì)轉(zhuǎn)到運(yùn)行狀態(tài)。阻塞的情況分三種：

（一）、等待阻塞：運(yùn)行的線程執(zhí)行wait()方法，JVM會(huì)把該線程放入等待池中。(wait會(huì)釋放持有的鎖)

（二）、同步阻塞：運(yùn)行的線程在獲取對(duì)象的同步鎖時(shí)，若該同步鎖被別的線程占用，則JVM會(huì)把該線程放入鎖池中。

（三）、其他阻塞：運(yùn)行的線程執(zhí)行sleep()或join()方法，或者發(fā)出了I/O請(qǐng)求時(shí)，JVM會(huì)把該線程置為阻塞狀態(tài)

當(dāng)sleep()狀態(tài)超時(shí)、join()等待線程終止或者超時(shí)、或者I/O處理完畢時(shí)，線程重新轉(zhuǎn)入就緒狀態(tài)。（注意,sleep是不會(huì)釋放持有的鎖）

5、死亡狀態(tài)（Dead）：線程執(zhí)行完了或者因異常退出了run()方法，該線程結(jié)束生命周期。

線程構(gòu)造方法：

Java 中實(shí)現(xiàn)線程的三種方式總結(jié)

1. 繼承Thread類

• 實(shí)現(xiàn)方式：

  • 編寫一個(gè)類，直接繼承 java.lang.Thread。
  • 重寫 run() 方法，定義線程執(zhí)行的任務(wù)。

• 創(chuàng)建線程對(duì)象：

  MyThread thread = new MyThread();
  

• 啟動(dòng)線程：

  thread.start();
  

• 特點(diǎn)：

  • 簡(jiǎn)單易用，但 Java 是單繼承，繼承 Thread 類后無(wú)法繼承其他類。

2. 實(shí)現(xiàn)Runnable接口

• 實(shí)現(xiàn)方式：

  • 編寫一個(gè)類，實(shí)現(xiàn) java.lang.Runnable 接口。
  • 實(shí)現(xiàn) run() 方法，定義線程執(zhí)行的任務(wù)。
  • 通常使用匿名內(nèi)部類創(chuàng)建。

• 創(chuàng)建線程對(duì)象：

  Runnable task = new MyRunnable();
  Thread thread = new Thread(task);
  

• 啟動(dòng)線程：

  thread.start();
  

• 特點(diǎn)：

  • 更靈活，可以避免單繼承的限制。
  • 適合多個(gè)線程共享同一個(gè)任務(wù)。

3. 使用Callable和Future接口

• 實(shí)現(xiàn)方式：

  • 編寫一個(gè)類，實(shí)現(xiàn) java.util.concurrent.Callable 接口。
  • 實(shí)現(xiàn) call() 方法，定義線程執(zhí)行的任務(wù)，并返回結(jié)果。

• 創(chuàng)建線程對(duì)象：

  1. 創(chuàng)建 Callable 實(shí)現(xiàn)類的實(shí)例：

     Callable<Integer> task = new MyCallable();
     

  2. 使用 FutureTask 包裝 Callable 對(duì)象：

     FutureTask<Integer> futureTask = new FutureTask<>(task);
     

  3. 使用 FutureTask 對(duì)象作為 Thread 的 target 創(chuàng)建線程：

     Thread thread = new Thread(futureTask);
     

• 啟動(dòng)線程：

  thread.start();
  

• 獲取結(jié)果：

  Integer result = futureTask.get(); // 阻塞直到獲取結(jié)果
  

• 特點(diǎn)：

  • call() 方法可以有返回值和拋出異常。
  • 適合需要獲取線程執(zhí)行結(jié)果的場(chǎng)景。

Future接口的常用方法

• cancel(boolean mayInterruptIfRunning)：嘗試取消任務(wù)。
• get()：獲取任務(wù)結(jié)果，阻塞直到任務(wù)完成。
• get(long timeout, TimeUnit unit)：在指定時(shí)間內(nèi)獲取任務(wù)結(jié)果，超時(shí)拋出 TimeoutException。
• isCancelled()：判斷任務(wù)是否被取消。
• isDone()：判斷任務(wù)是否完成。

三種方式的對(duì)比

總結(jié)

• 繼承 Thread 類：適合簡(jiǎn)單的線程任務(wù)，但受限于單繼承。
• 實(shí)現(xiàn) Runnable 接口：更靈活，適合多線程共享任務(wù)。
• 使用 Callable 和 Future：適合需要獲取線程執(zhí)行結(jié)果或處理異常的場(chǎng)景。

根據(jù)具體需求選擇合適的方式實(shí)現(xiàn)多線程編程。

獲取當(dāng)前線程對(duì)象、獲取線程對(duì)象名字、修改線程對(duì)象名字

關(guān)于線程的sleep方法

關(guān)于線程中斷sleep()的方法

Java進(jìn)程的優(yōu)先級(jí)

方法：

多線程并發(fā)環(huán)境下，數(shù)據(jù)的安全問(wèn)題（重點(diǎn)）

1.為什么這個(gè)是重點(diǎn)？

以后在開發(fā)中，我們的項(xiàng)目都是運(yùn)行在服務(wù)器當(dāng)中，而服務(wù)器已經(jīng)將線程的定義，線程對(duì)象的創(chuàng)建，線程的啟動(dòng)等，都已經(jīng)實(shí)現(xiàn)完了。這些代碼我們都不需要編寫。

最重要的是： 你要知道，你編寫的程序需要放到一個(gè)多線程的環(huán)境下運(yùn)行，你更需要關(guān)注的是這些數(shù)據(jù)在多線程并發(fā)的環(huán)境下是否是安全的。（重點(diǎn)：★★★★★）

2.什么時(shí)候數(shù)據(jù)在多線程并發(fā)的環(huán)境下會(huì)存在安全問(wèn)題呢？★★★★★

滿足三個(gè)條件：

條件1：多線程并發(fā)。

條件2：有共享數(shù)據(jù)。

條件3：共享數(shù)據(jù)有修改的行為。

滿足以上3個(gè)條件之后，就會(huì)存在線程安全問(wèn)題。

3.怎么解決線程安全問(wèn)題呢？

當(dāng)多線程并發(fā)的環(huán)境下，有共享數(shù)據(jù)，并且這個(gè)數(shù)據(jù)還會(huì)被修改，此時(shí)就存在線程安全問(wèn)題，怎么解決這個(gè)問(wèn)題？

線程排隊(duì)執(zhí)行。（不能并發(fā)）。用排隊(duì)執(zhí)行解決線程安全問(wèn)題。

這種機(jī)制被稱為：線程同步機(jī)制。專業(yè)術(shù)語(yǔ)叫做：線程同步，實(shí)際上就是線程不能并發(fā)了，線程必須排隊(duì)執(zhí)行。

線程同步就是線程排隊(duì)了，線程排隊(duì)了就會(huì) 犧牲一部分效率 ，數(shù)據(jù)安全第一位，只有數(shù)據(jù)安全了，我們才可以談效率。數(shù)據(jù)不安全，沒(méi)有效率的事兒。

死鎖（DeadLock）

死鎖（Deadlock）是多線程編程中的一種常見(jiàn)問(wèn)題，指的是兩個(gè)或多個(gè)線程在執(zhí)行過(guò)程中，因?yàn)闋?zhēng)奪資源而造成的一種互相等待的現(xiàn)象，導(dǎo)致這些線程都無(wú)法繼續(xù)執(zhí)行下去。

死鎖代碼要會(huì)寫。一般面試官要求你會(huì)寫。只有會(huì)寫的，才會(huì)在以后的開發(fā)中注意這個(gè)事兒。因?yàn)樗梨i很難調(diào)試。

死鎖的四個(gè)必要條件

死鎖的發(fā)生必須同時(shí)滿足以下四個(gè)條件：

1. 互斥條件（Mutual Exclusion）：

   • 資源一次只能被一個(gè)線程占用。

2. 占有并等待（Hold and Wait）：

   • 線程已經(jīng)占有了至少一個(gè)資源，但又申請(qǐng)新的資源，而新的資源被其他線程占用。

3. 不可搶占（No Preemption）：

   • 線程已占有的資源不能被其他線程強(qiáng)行搶占，必須由線程自己釋放。

4. 循環(huán)等待（Circular Wait）：

   • 存在一個(gè)線程的等待循環(huán)鏈，每個(gè)線程都在等待下一個(gè)線程所占用的資源。

Java 中的死鎖示例

以下是一個(gè)經(jīng)典的死鎖代碼示例，展示了兩個(gè)線程互相等待對(duì)方釋放鎖的情況：

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try {
                    Thread.sleep(100); // 模擬操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread 1: Acquired lock 2!");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");
                try {
                    Thread.sleep(100); // 模擬操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for lock 1...");
                synchronized (lock1) {
                    System.out.println("Thread 2: Acquired lock 1!");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

代碼分析

1. 線程1：

   • 先獲取lock1，然后嘗試獲取lock2。
   • 在獲取lock2之前，線程1會(huì)休眠100毫秒。

2. 線程2：

   • 先獲取lock2，然后嘗試獲取lock1。
   • 在獲取lock1之前，線程2會(huì)休眠100毫秒。

3. 死鎖發(fā)生：

   • 線程1持有lock1并等待lock2。
   • 線程2持有lock2并等待lock1。
   • 兩個(gè)線程互相等待，導(dǎo)致死鎖。

如何避免死鎖

1. 避免嵌套鎖：

   • 盡量不要在持有一個(gè)鎖的同時(shí)去申請(qǐng)另一個(gè)鎖。

2. 按順序獲取鎖：

   • 如果多個(gè)線程需要獲取多個(gè)鎖，確保它們以相同的順序獲取鎖。

3. 使用超時(shí)機(jī)制：

   • 在獲取鎖時(shí)設(shè)置超時(shí)時(shí)間，如果超時(shí)則釋放已持有的鎖并重試。

4. 使用工具檢測(cè)：

   • 使用工具（如jstack）檢測(cè)死鎖。

死鎖的調(diào)試與檢測(cè)

1. 使用jstack：

   • 運(yùn)行程序后，使用jstack命令查看線程狀態(tài)，可以檢測(cè)到死鎖。

2. 日志輸出：

   • 在代碼中添加日志，記錄鎖的獲取和釋放情況。

3. 使用工具：

   • 使用IDE（如IntelliJ IDEA）或第三方工具（如VisualVM）檢測(cè)死鎖。

守護(hù)線程

在Java中，線程分為兩大類：用戶線程和守護(hù)線程。守護(hù)線程（Daemon Thread）是一種特殊的線程，它的生命周期依賴于用戶線程。當(dāng)所有的用戶線程結(jié)束時(shí)，守護(hù)線程會(huì)自動(dòng)退出。

守護(hù)線程的特點(diǎn)

1. 依賴用戶線程：

   • 守護(hù)線程是為用戶線程提供服務(wù)的線程。
   • 當(dāng)所有的用戶線程結(jié)束時(shí)，守護(hù)線程會(huì)自動(dòng)退出。

2. 典型代表：

   • 垃圾回收線程（GC）是Java中最典型的守護(hù)線程。

3. 主線程是用戶線程：

   • main方法所在的線程是用戶線程。

4. 死循環(huán)：

   • 守護(hù)線程通常是一個(gè)死循環(huán)，持續(xù)執(zhí)行某些后臺(tái)任務(wù)。

守護(hù)線程的應(yīng)用場(chǎng)景

1. 定時(shí)任務(wù)：

   • 例如，每天00:00自動(dòng)備份系統(tǒng)數(shù)據(jù)。
   • 可以使用定時(shí)器（如Timer或ScheduledExecutorService），并將定時(shí)任務(wù)設(shè)置為守護(hù)線程。

2. 后臺(tái)監(jiān)控：

   • 例如，監(jiān)控系統(tǒng)資源使用情況、日志清理等。

3. 垃圾回收：

   • Java的垃圾回收線程就是一個(gè)守護(hù)線程。

守護(hù)線程的設(shè)置

在Java中，可以通過(guò)setDaemon(boolean on)方法將一個(gè)線程設(shè)置為守護(hù)線程：

注意：

• 必須在調(diào)用start()方法之前設(shè)置守護(hù)線程，否則會(huì)拋出IllegalThreadStateException。
• 守護(hù)線程中創(chuàng)建的子線程默認(rèn)也是守護(hù)線程。

代碼示例

以下是一個(gè)守護(hù)線程的示例，展示了如何設(shè)置守護(hù)線程以及它的行為：

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("守護(hù)線程正在運(yùn)行...");
                try {
                    Thread.sleep(1000); // 模擬任務(wù)執(zhí)行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 設(shè)置為守護(hù)線程
        daemonThread.setDaemon(true);

        // 啟動(dòng)守護(hù)線程
        daemonThread.start();

        // 主線程（用戶線程）執(zhí)行任務(wù)
        System.out.println("主線程開始執(zhí)行...");
        try {
            Thread.sleep(5000); // 模擬主線程執(zhí)行任務(wù)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主線程執(zhí)行完畢，程序退出。");
    }
}

代碼分析

1. 守護(hù)線程：

   • 守護(hù)線程是一個(gè)死循環(huán)，每隔1秒輸出一條消息。
   • 設(shè)置為守護(hù)線程后，當(dāng)主線程結(jié)束時(shí)，守護(hù)線程會(huì)自動(dòng)退出。

2. 主線程：

   • 主線程執(zhí)行5秒后結(jié)束。
   • 主線程結(jié)束后，守護(hù)線程也會(huì)自動(dòng)退出。

守護(hù)線程的注意事項(xiàng)

1. 資源釋放：

   • 守護(hù)線程中不要執(zhí)行關(guān)鍵任務(wù)（如文件寫入、數(shù)據(jù)庫(kù)操作等），因?yàn)樗耐顺鍪遣豢煽氐摹?/li>

2. 線程優(yōu)先級(jí)：

   • 守護(hù)線程的優(yōu)先級(jí)通常較低，適合執(zhí)行后臺(tái)任務(wù)。

3. 生命周期：

   • 守護(hù)線程的生命周期依賴于用戶線程，不能獨(dú)立存在。

定時(shí)器的作用：

間隔特定的時(shí)間，執(zhí)行特定的程序。在實(shí)際的開發(fā)中，每隔多久執(zhí)行一段特定的程序，這種需求是很常見(jiàn)的，那么在java中其實(shí)可以采用多種方式實(shí)現(xiàn)：

可以使用sleep方法，睡眠，設(shè)置睡眠時(shí)間，沒(méi)到這個(gè)時(shí)間點(diǎn)醒來(lái)，執(zhí)行任務(wù)。這種方式是最原始的定時(shí)器。（比較low）

在java的類庫(kù)中已經(jīng)寫好了一個(gè)定時(shí)器：java.util.Timer，可以直接拿來(lái)用。

不過(guò)，這種方式在目前的開發(fā)中也很少用，因?yàn)楝F(xiàn)在有很多高級(jí)框架都是支持定時(shí)任務(wù)的。

在實(shí)際的開發(fā)中，目前使用較多的是Spring框架中提供的SpringTask框架，這個(gè)框架只要進(jìn)行簡(jiǎn)單的配置，就可以完成定時(shí)器的任務(wù)。

關(guān)于Object類的wait()、notify()、notifyAll()方法

wait和notify方法不是線程對(duì)象的方法，是java中任何一個(gè)java對(duì)象都有的方法，因?yàn)檫@兩個(gè)方法是 Object類中自帶 的。

wait方法和notify方法不是通過(guò)線程對(duì)象調(diào)用

調(diào)用：

Object o = new Object();

o.wait();

總結(jié) ★★★★★（呼應(yīng)生產(chǎn)者消費(fèi)者模式）

1、wait和notify方法不是線程對(duì)象的方法，是普通java對(duì)象都有的方法。

2、wait方法和notify方法建立在 線程同步 的基礎(chǔ)之上。因?yàn)槎嗑€程要同時(shí)操作一個(gè)倉(cāng)庫(kù)。有線程安全問(wèn)題。

3、wait方法作用：o.wait() 讓正在o對(duì)象上活動(dòng)的線程t進(jìn)入等待狀態(tài)，并且釋放掉t線程之前占有的o對(duì)象的鎖

4、notify方法作用：o.notify() 讓正在o對(duì)象上等待的線程喚醒，只是通知，不會(huì)釋放o對(duì)象上之前占有的鎖。

生產(chǎn)者消費(fèi)者模式（wait()和notify()）

什么是“生產(chǎn)者和消費(fèi)者模式”？

生產(chǎn)線程負(fù)責(zé)生產(chǎn)，消費(fèi)線程負(fù)責(zé)消費(fèi)。

生產(chǎn)線程和消費(fèi)線程要達(dá)到均衡。

這是一種特殊的業(yè)務(wù)需求，在這種特殊的情況下需要使用wait方法和notify方法。

模擬一個(gè)業(yè)務(wù)需求

倉(cāng)庫(kù)我們采用List集合。

List集合中假設(shè)只能存儲(chǔ)1個(gè)元素。

1個(gè)元素就表示倉(cāng)庫(kù)滿了。

如果List集合中元素個(gè)數(shù)是0，就表示倉(cāng)庫(kù)空了。

保證List集合中永遠(yuǎn)都是最多存儲(chǔ)1個(gè)元素。

必須做到這種效果：生產(chǎn)1個(gè)消費(fèi)1個(gè)。

十五、反射

1. Class 對(duì)象概述

• Class 對(duì)象：在 Java 中，每個(gè)類在加載到內(nèi)存時(shí)都會(huì)生成一個(gè) Class 對(duì)象，該對(duì)象存儲(chǔ)了類的所有信息（如方法、構(gòu)造函數(shù)、字段等）。
• 反射：通過(guò) Class 對(duì)象，可以在運(yùn)行時(shí)動(dòng)態(tài)獲取類的信息并操作類的成員（如調(diào)用方法、訪問(wèn)字段等）。

2. Class 對(duì)象的生成方式

1. 類名.class：

   • JVM 將類加載到內(nèi)存中，但不進(jìn)行初始化。

   • 返回該類的 Class 對(duì)象。

   • 示例：

     Class<?> clazz = String.class;
     

2. Class.forName("包名.類名")：

   • 加載類并默認(rèn)進(jìn)行靜態(tài)初始化。

   • 返回該類的 Class 對(duì)象。

   • 示例：

     Class<?> clazz = Class.forName("java.lang.String");
     

3. Class.forName("包名.類名", false, 類加載器)：

   • 第二個(gè)參數(shù)為 false 時(shí)，不進(jìn)行初始化；為 true 時(shí)，進(jìn)行初始化。

   • 示例：

     Class<?> clazz = Class.forName("java.lang.String", false, ClassLoader.getSystemClassLoader());
     

4. 實(shí)例對(duì)象.getClass()：

   • 對(duì)類進(jìn)行靜態(tài)初始化和非靜態(tài)初始化。

   • 返回運(yùn)行時(shí)實(shí)際對(duì)象所屬類的 Class 對(duì)象。

   • 示例：

     String str = "Hello";
     Class<?> clazz = str.getClass();
     

3. Class 對(duì)象的特性

• 父子類 Class 對(duì)象不一致：
  • 如果 A 是 B 的子類，則 A.class 和 B.class 返回的 Class 對(duì)象不同。
  • 如果 a 是 A 的實(shí)例，則 A.class 和 a.getClass() 返回的 Class 對(duì)象一致。

4. Class 類的常用方法

• getName()：返回類的全限定名（包名 + 類名）。
• getSuperclass()：返回類的直接父類的 Class 對(duì)象。
• getInterfaces()：返回類實(shí)現(xiàn)的所有接口的 Class 數(shù)組。
• isArray()：判斷該類是否是數(shù)組類型。
• isEnum()：判斷該類是否是枚舉類型。
• isInterface()：判斷該類是否是接口。
• isPrimitive()：判斷該類是否是基本類型（如 int、boolean 等）。
• isAssignableFrom(Class cls)：判斷該類是否是 cls 的父類或父接口。
• getComponentType()：如果該類是數(shù)組類型，返回?cái)?shù)組的組件類型。
• asSubclass(Class clazz)：將當(dāng)前 Class 對(duì)象轉(zhuǎn)換為 clazz 的子類類型。

5.asSubclass方法的使用

• 作用：將當(dāng)前 Class 對(duì)象轉(zhuǎn)換為指定類的子類類型。

• 示例：

  List<String> strList = new ArrayList<>();
  Class<? extends List> strListCast = strList.getClass().asSubclass(List.class);
  

• 動(dòng)態(tài)加載時(shí)的應(yīng)用：

  Class.forName("xxx.xxx.xxx").asSubclass(List.class).newInstance();
  

  • 如果 xxx.xxx.xxx 是 List 的子類，則正常執(zhí)行；否則拋出 ClassCastException。

6. 靜態(tài)加載與動(dòng)態(tài)加載

• 靜態(tài)加載：通過(guò) new ClassName() 加載類，編譯時(shí)必須提供類的定義。
• 動(dòng)態(tài)加載：通過(guò) Class.forName("ClassName") 加載類，編譯時(shí)可以缺席，運(yùn)行時(shí)按需提供。

總結(jié)

• Class 對(duì)象：存儲(chǔ)類的所有信息，是反射機(jī)制的核心。
• 生成方式：類名.class、Class.forName()、實(shí)例對(duì)象.getClass()。
• 常用方法：getName()、getSuperclass()、getInterfaces()、asSubclass() 等。
• asSubclass：用于將 Class 對(duì)象轉(zhuǎn)換為指定類的子類類型。
• 靜態(tài)加載與動(dòng)態(tài)加載：靜態(tài)加載在編譯時(shí)提供類定義，動(dòng)態(tài)加載在運(yùn)行時(shí)按需提供。

通過(guò)掌握 Class 對(duì)象和反射機(jī)制，可以在運(yùn)行時(shí)動(dòng)態(tài)操作類的成員，實(shí)現(xiàn)靈活的編程。

十六、小游戲（進(jìn)擊的小鳥）

public class StartGame {           //游戲開始類
  public static void main(String[] args) throws InterruptedException {
    JFrame jFrame = new JFrame("進(jìn)擊の小鳥");  //創(chuàng)建窗口對(duì)象
    jFrame.setSize(400,600);//窗口大小
    jFrame.setLocationRelativeTo(null); //窗口相對(duì)位置
    jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//設(shè)定點(diǎn)擊關(guān)閉結(jié)束程序

?    BirdGame birdGame = new BirdGame();  //初始化游戲?qū)ο箢?
?    jFrame.add(birdGame);         //把創(chuàng)建好的對(duì)象加進(jìn)來(lái)
?    jFrame.setVisible(true);       //讓窗口可視化
?    birdGame.action();          //地面運(yùn)動(dòng)方法

  }
}

public class Bird {
  public BufferedImage images[];
  public BufferedImage image;   //存放小鳥圖片
  public int x;
  public int y;
  public int width;
  public int height;
  public int index=0;
  public double speed=0;    //小鳥初始速度
  public double upspeed=30;  //初始上拋速度
  public double s=0;      //經(jīng)過(guò)t，發(fā)生的位移
  public double t=0.2;     //發(fā)生位移時(shí)間
  public double g=9.8;     //重力加速度
  public Bird() throws IOException {
    x=120;
    y=120;
    images=new BufferedImage[8];
    image= ImageIO.read(getClass().getResource("0.png"));
    width=image.getWidth();
    height=image.getHeight();
    for (int i=0;i<images.length;i++) {
      images[i] = ImageIO.read(getClass().getResource(i+".png"));
    }
  }


  public void fly(){      //小鳥飛飛
    index++;
    image=images[index/2%8];
  }
  public void upSpeed(){    //鼠標(biāo)點(diǎn)擊游戲屏幕，給小鳥一個(gè)初始上拋速度
    speed=upspeed;
  }
  public void distanceChange(){  //實(shí)現(xiàn)小鳥速度，位移，縱坐標(biāo)變化
    double v=speed; //初始速度
    s=v*t-g*t*t/2;  //經(jīng)過(guò)t小鳥的位移
    speed=v-g*t;   //小鳥經(jīng)過(guò)時(shí)間t的末速度
    y=y-(int)s;      //經(jīng)過(guò)時(shí)間t后，小鳥的y

  }
}

public class Column {    //管道類
  public BufferedImage cImage;
  public int x;
  public  int y;
  public int width;
  public int height;
  public  int distance=270;  //兩根管道之間的距離
  public static  int count=0;
  Random random = new Random();
  public Column() throws IOException {
    cImage= ImageIO.read(getClass().getResource("column.png"));
    x=450+distance*count;
    width=cImage.getWidth();   //獲得管道的寬
    height=cImage.getHeight();  //高
    y=-( height/2-random.nextInt(300)-50);


    count++;
  }
  public void step(){
    x-=5; //讓地面往左運(yùn)動(dòng)
    if (x<=-width/2){
      x=x+distance*2;
      y=-(height/2-random.nextInt(300)-50) ;
      //x=400;
    }
  }
}

public class Ground {  //地面類
  public BufferedImage image; //存放地面圖片
  public int x;
  public int y;

  public Ground() {

?    try {
?      x=0;
?      y=500;
?      image= ImageIO.read(getClass().getResource("ground.png"));
?    } catch (IOException e) {
?      e.printStackTrace();
?    }
  }
  public void step(){
?    x-=1; //讓地面往左運(yùn)動(dòng)
?    if (x==-100){
?      x=0;
?    }
  }
}

public class Music implements Runnable {    //音樂(lè)類
  Player player=null;
  @Override
  public void run() {
    InputStream resourceAsStream = this.getClass().getResourceAsStream("2.mp3");
    try {
      player=new Player(resourceAsStream);
      player.play();
    } catch (JavaLayerException e) {
      e.printStackTrace();
    }

  }
  public void stopBGM(){
  if (player!=null)
      player.close();

  }
}

public class Score {  //連接對(duì)象
  private String sid;
  private int score;
  private String time;

  public String getSid() {
    return sid;
  }

  public void setSid(String sid) {
    this.sid = sid;
  }

  public int getScore() {
    return score;
  }

  public void setScore(int score) {
    this.score = score;
  }

  public String getTime() {
    return time;
  }

  public void setTime(String time) {
    this.time = time;
  }
}

public class ScoreManager {   //jdbc連接
  static{
    try {
      Class.forName("com.mysql.cj.jdbc.Driver");
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
  public List<Score> selectAllScore(){     //查詢方法
    List<Score> list = new ArrayList<>();

?    try {
?      String sql="select * from score order by time";
?      Connection conn = DriverManager.getConnection("jdbc:mysql://cdb-kthncrwi.bj.tencentcdb.com:10159/flybird?useUnicode=true", "student", "521qianfeng");
?      PreparedStatement pst = conn.prepareStatement(sql);
?      ResultSet resultSet = pst.executeQuery();
?      while (resultSet.next()){
?        Score score = new Score();
?        score.setSid(resultSet.getString("sid"));
?        score.setScore(resultSet.getInt("score"));
?        score.setTime(resultSet.getString("time"));
?        list.add(score);
?      }
?    } catch (SQLException e) {
?      e.printStackTrace();
?    }

?    return list;
  }
  public int insertScore(int score) {     //插入方法
?    int num = 0;
?    String sql = "insert into score(sid,score,time) value(?,?,?)";
?    try {
?      Connection conn = DriverManager.getConnection("jdbc:mysql://cdb-kthncrwi.bj.tencentcdb.com:10159/flybird?useUnicode=true", "student", "521qianfeng");
?      PreparedStatement pst = conn.prepareStatement(sql);
?      String sid= UUID.randomUUID().toString();     //隨機(jī)生成id
?      pst.setString(1,sid);
?      pst.setInt(2,score);
?      Date date = new Date();
?      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");     //創(chuàng)建時(shí)間類型對(duì)象
?      String time=simpleDateFormat.format(date);
?      pst.setString(3,time);
?      num=pst.executeUpdate();
?    } catch (SQLException e) {
?      e.printStackTrace();
?    }
?    return num;

  }
}

public class BirdGame extends JPanel {   //自定義面板類繼承面板類
  ScoreManager sc=new ScoreManager();
  public JPanel jp=new JPanel();
  public BufferedImage bg;         //圖片緩沖區(qū)（在顯示圖片前對(duì)圖片進(jìn)行操作 eg：.getWidth()寬，.getHeight()高）
  public BufferedImage startbg;
  public BufferedImage overbg;
  public Ground ground;
  public Bird bird;
  public Column columns[];
  public Music music;

  String file="H:\\Java程序\\小程序\\src\\小鳥\\png\\bg.png";

  public int state; //表示游戲狀態(tài)
  public static final int START=0;   //開始
  public static final int RUNNING=1;  //運(yùn)行
  public static final int GAMEOVER=2; //結(jié)束
  public static int score=0;      //初始積分

  public BirdGame(){
    try {
      state=START;         //游戲初始為游戲開始狀態(tài)
      ground=new Ground();     //創(chuàng)建地面類對(duì)象，調(diào)用地面類構(gòu)造方法
      bird = new Bird();
      columns=new Column[2];
      music = new Music();
      for (int i=0;i<columns.length;i++){
        columns[i]=new Column();
      }
      bg= ImageIO.read(getClass().getResource("bg.png")); //讀取這張圖片并把圖片值賦給變量
      //bg=ImageIO.read(new File(file));
      //bg=ImageIO.read(new File("src/小鳥/png/bg.png"));
      startbg=ImageIO.read(getClass().getResource("start.png"));
      overbg=ImageIO.read(getClass().getResource("gameover.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
   }



  @Override
  public void paint(Graphics g) {         //繪制一次的畫畫方法
    super.paint(g);               //調(diào)用畫筆
    g.drawImage(bg,0,0,null);            //繪制背景（最后一個(gè)參數(shù)為觀察者
    switch (state){
      case START:
        //繪制游戲開始圖片
        settishi(g);
        g.drawImage(startbg,0,0,null);

?        break;
?      case RUNNING:
?        for (int i=0;i<columns.length;i++) {
?          g.drawImage(columns[i].cImage, columns[i].x, columns[i].y, null);
?        }
?        break;
?      case GAMEOVER:
?        //繪制游戲結(jié)束圖片
?        settishi2(g);
?        g.drawImage(overbg,0,0,null);

?        break;

?    }
?    g.drawImage(ground.image,ground.x,ground.y,null);  //繪制地面
?    g.drawImage(bird.image,bird.x, bird.y,null);     //繪制小鳥

?    setScore(g);
  }
  public boolean isHitGround(){      //撞擊地面
?    if (bird.y+bird.height>500){
?      return true;
?    }else {
?      return false;
?    }
  }
  public boolean isHitSky(){      //撞擊天空
?    if (bird.y<0){
?      return true;
?    }else {
?      return false;
?    }
  }
  public boolean isguandao(Column c) {
?    if (bird.x + bird.width >= c.x && c.x + c.width >= bird.x) {   //撞擊管道左右
?      if (bird.y <= c.height / 2 + c.y - 72 || bird.y + bird.height >= c.height / 2 + c.y + 72) {
?        return true;
?      } else {
?        return false;
?      }

?    } else {
?      return false;
?    }
  }

  public void setScore(Graphics g){               //繪制分?jǐn)?shù)方法
    Font font = new Font(Font.SERIF, Font.ITALIC, 40);  //羅馬字體，斜體，40號(hào)
    g.setFont(font);     //獲取字體
    g.setColor(Color.white);//獲取顏色
    g.drawString(score+"分",40,60);    //畫字符串
  }
  public void settishi(Graphics g){               //繪制分?jǐn)?shù)方法
    Font font1 = new Font(Font.SERIF, Font.BOLD, 25);  //羅馬字體，斜體，40號(hào)
    g.setFont(font1);     //獲取字體
    g.setColor(Color.black);//獲取顏色
    g.drawString("點(diǎn)擊屏幕開始運(yùn)行",110,400);    //畫字符串
    g.drawString("   制作人---趙嘉盟",120,430);
  }
  public void settishi2(Graphics g){               //繪制分?jǐn)?shù)方法
    Font font2 = new Font(Font.SANS_SERIF, Font.BOLD, 30);  //羅馬字體，斜體，40號(hào)
    g.setFont(font2);     //獲取字體
    g.setColor(Color.red);//獲取顏色
    g.drawString("點(diǎn)擊屏幕重新開始",100,500);    //畫字符串
  }
  public void action() throws InterruptedException {    //游戲?qū)ο筮\(yùn)動(dòng)方法
    this.addMouseListener(new BirdMouseListener());   //添加鼠標(biāo)監(jiān)聽器

?    while (true){
?      switch (state){     //狀態(tài)不同，對(duì)象運(yùn)動(dòng)效果不同
?        case START:
?          ground.step();  //調(diào)用地面運(yùn)動(dòng)方法
?          bird.fly();


          break;
        case RUNNING:

?          bird.distanceChange();
?          ground.step();  //調(diào)用地面運(yùn)動(dòng)方法
?          bird.fly();

?          if (isHitGround()||isHitSky()){
?            state=GAMEOVER;
?            break;
?          }
?          for (int i=0;i<columns.length;i++){
?            Column cl=columns[i];
?            cl.step();
?            if (isguandao(cl)){
?              state=GAMEOVER;
?              break;
?            }
?            if (bird.x==cl.x){
?              score++;
?            }
?          }

?          break;
?        case GAMEOVER:
?          music.stopBGM();
?          break;
?      }
?      repaint();  //刷新方法（重新繪制）
?      Thread.sleep(50);  //線程睡眠
?    }
  }
  class BirdMouseListener extends MouseAdapter{      //小鳥飛行鼠標(biāo)控制監(jiān)聽內(nèi)部類
?    @Override
?    public void mousePressed(MouseEvent e) {
?      super.mousePressed(e);

?      switch (state){
?        case START:
?          state=RUNNING;  //鼠標(biāo)點(diǎn)擊開始運(yùn)行
?          Thread thread = new Thread(music);
?          thread.start();
?          break;
?        case RUNNING:
?          bird.upSpeed(); //鼠標(biāo)點(diǎn)擊屏幕給小鳥一個(gè)初始上拋速度
?          break;
?        case GAMEOVER:
?          sc.insertScore(score);  //向數(shù)據(jù)庫(kù)插入分?jǐn)?shù)
?          List<Score> scores = sc.selectAllScore();//查詢數(shù)據(jù)庫(kù)所有分?jǐn)?shù)
?          String message="";
?          for (Score score1 : scores) {
?            message=message+"時(shí)間："+score1.getTime()+"\n分?jǐn)?shù)："+score1.getScore()+"\n";
?          }
?          JOptionPane.showConfirmDialog(jp,message,"實(shí)時(shí)分?jǐn)?shù)",JOptionPane.WARNING_MESSAGE);
?          state=START;   //鼠標(biāo)點(diǎn)擊游戲恢復(fù)開始狀態(tài)

?          bird.x=120;
?          bird.y=220;
?          bird.speed=0;
?          Column.count=0;
?          try {
?            columns[0] = new Column();
?          } catch (IOException ex) {
?            ex.printStackTrace();
?          }
?          try {
?            columns[1] = new Column();
?          } catch (IOException ex) {
?            ex.printStackTrace();
?          }
?          score = 0;//給積分初始化
?          for (int i=0;i<columns.length;i++){
?            try {
?              columns[i]=new Column();
?            } catch (IOException ex) {
?              ex.printStackTrace();
?            }
?          }

?          break;

?      }
?    }
  }
}

十七、Stream

Stream簡(jiǎn)介

Java 8 中的 Stream 是對(duì)（Collection）集合對(duì)象功能的增強(qiáng)，它專注于對(duì)集合對(duì)象進(jìn)行各種非常便利、高效的聚合操作

或大批量數(shù)據(jù)操作。Stream API 借助于同樣新出現(xiàn)的 Lambda 表達(dá)式，極大的提高編程效率和程序可讀性。

Stream原理

這種編程風(fēng)格將要處理的元素集合看作一種流，流在管道中傳輸，并且可以在管道的節(jié)點(diǎn)上進(jìn)行處理，比如篩選，排序，聚合等。

元素流在管道中經(jīng)過(guò)中間操作（intermediate operation）的處理，最后由最終操作(terminal operation)得到前面處理的

結(jié)果。

Stream優(yōu)點(diǎn)

（1）速度更快

（2）代碼更少（增加了新的語(yǔ)法Lambda表達(dá)式）

（3）強(qiáng)大的Stream API

（4）便于并行

（5）最大化減少了空指針異常Optional

Stream的操作三個(gè)步驟：

（1）創(chuàng)建Stream，一個(gè)數(shù)據(jù)源（如：集合、數(shù)組），獲取一個(gè)流；

（2）中間操作，一個(gè)中間操作鏈，對(duì)數(shù)據(jù)源的數(shù)據(jù)進(jìn)行處理；

（3）終止操作，一個(gè)終止操作，執(zhí)行中間操作鏈，并產(chǎn)生結(jié)果。

集合有兩種方式生成流：

stream() − 為集合創(chuàng)建串行流。

parallelStream() − 為集合創(chuàng)建并行流

-Stream的的中間操作（intermediate）和最終操作（terminal）都包含的方法:

中間操作（intermediate）

1.filter : 通過(guò)設(shè)置條件來(lái)過(guò)濾元素。

List<String> list = Arrays.asList("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");

list.stream().filter((s)->s.contains("a")).forEach(s -> System.out.println(s));

以上代碼使用filter方法過(guò)濾出只包含”a”的元素，然后通過(guò)forEach將滿足條件的元素遍歷出來(lái)。

map : 就是將對(duì)應(yīng)的元素使用給定方法進(jìn)行轉(zhuǎn)換。

List<String> list = Arrays.asList("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");

list.stream().filter((s)->s.contains("a")).map((s)-> s + "---map").forEach(s -> System.out.println(s));

在filter的基礎(chǔ)上，給每個(gè)元素后面添加字符串”—map”

flatMap：如果流的元素為數(shù)組或者Collection，flatMap就是將每個(gè)Object[]元素或Collection元素都轉(zhuǎn)換為Object元素。

List<String[]> setList = new ArrayList<>();

setList.add(new String[]{"aa","bb"});

setList.add(new String[]{"cc","dd"});

setList.add(new String[]{"ee","ff"});//使用map方法

setList.stream().map(s->Arrays.stream(s)).forEach(s-> System.out.println("map==" + s));//使用flatMap方法

setList.stream().flatMap(s->Arrays.stream(s)).forEach(s-> System.out.println("flatMap==" + s));

map就是將數(shù)組流直接返回，flatMap是將數(shù)組流中的每個(gè)元素都返回。

.distinct：將集合中的元素去重。

List<String> disList = Arrays.asList("aaa","ddd","bbb","ddd","aaa");

disList.stream().distinct().forEach(s-> System.out.println(s));

sorted：將集合中的元素排序。

List<Integer> integerList = Arrays.asList(2,4,1,3);

integerList.stream().sorted().forEach(s-> System.out.println(s));

可以按照自定義排序：

List<Integer> integerList = Arrays.asList(2,4,1,3);

integerList.stream().sorted((s1,s2)->s2.compareTo(s1)).forEach(s-> System.out.println(s));

peek：生成一個(gè)包含原Stream的所有元素的新Stream，同時(shí)會(huì)提供一個(gè)消費(fèi)函數(shù)即引用的方法A，當(dāng)Stream每個(gè)元素被消費(fèi)的時(shí)候都會(huì)先
執(zhí)行新Stream給定的方法A。peek是中間操作，如果peek后沒(méi)有最終操作，則peek不會(huì)執(zhí)行。

List<Integer> integerList = Arrays.asList(1,2,3,4);

integerList.stream().peek(s-> System.out.println("peek = "+s)).forEach(s-> System.out.println("forEach = "+s));

limit：返回Stream的前n個(gè)元素。

List<Integer> integerList = Arrays.asList(1,2,3,4);

integerList.stream().limit(2).forEach(s-> System.out.println(s));

skip：刪除Stream的前n個(gè)元素。

List<Integer> integerList = Arrays.asList(1,2,3,4);

integerList.stream().skip(2).forEach(s-> System.out.println(s));

終端操作（terminal）

1.forEach：遍歷Stream中的每個(gè)元素，前面每個(gè)例子都有使用，此處不再演示。

List<Integer> integerList = Arrays.asList(1,2,3,4);

integerList.stream().skip(2).forEach(s-> System.out.println(s));

forEachOrdered:遍歷Stream中的每個(gè)元素。
區(qū)別： 在串行流（stream）中沒(méi)有區(qū)別，在并行流（parallelStream）中如果數(shù)據(jù)源是有序集合，forEachOrdered輸出順序與數(shù)據(jù)源中順序
一致，forEach則是亂序。

List<Integer> integerList = Arrays.asList(1,2,3,4);

integerList.parallelStream().forEachOrdered(s-> System.out.println(s));

toArray：將流轉(zhuǎn)換為Object[]或者指定類型的數(shù)組。

List<Integer> integerList = Arrays.asList(1,2,3,4);

Object[] array = integerList.stream().toArray();

String[] strArr = integerList.stream().toArray(String[]::new);

Stream中的toArray普通情況下和集合中的toArray沒(méi)什么區(qū)別,但是Stream中的toArray轉(zhuǎn)換為指定類型的數(shù)組。

reduce：將集合中的每個(gè)元素聚合成一條數(shù)據(jù)。有三種情況：

reduce(BinaryOperator accumulator)：此處需要一個(gè)參數(shù)，返回Optional對(duì)象：

Optional reduce = integerList.stream().reduce((a, b) -> a + b);

reduce(T identity, BinaryOperator accumulator)：此處需要兩個(gè)參數(shù)，第一個(gè)參數(shù)為起始值，第二個(gè)參數(shù)為引用的方法

從起始值開始，每個(gè)元素執(zhí)行一次引用的方法（方法引用的中的兩個(gè)參數(shù)：第一個(gè)參數(shù)為上個(gè)元素執(zhí)行方法引用的結(jié)果，第二個(gè)參數(shù)為當(dāng)前元素）。

  List<Integer> integerList = Arrays.asList(1,2,3,4);

  int integer = integerList.stream().reduce(5,(a, b) -> a + b);

  System.out.println(integer);

此例中使用起始值為5，對(duì)集合中每個(gè)元素求和，可以理解為：5+1+2+3+4=15。

**reduce：**此處需要三個(gè)參數(shù)。此方法用在并發(fā)流（parallelStream）中，啟動(dòng)多個(gè)子線程使用accumulator進(jìn)行并行計(jì)算，最終使用combiner對(duì)子線程結(jié)果進(jìn)行合并，返回identity類型的數(shù)據(jù)。

collect：將流轉(zhuǎn)換成集合或聚合元素。有兩種情況。接受一個(gè)參數(shù)和接受三個(gè)參數(shù)（三個(gè)參數(shù)在并發(fā)流parallelStream中使用），此處介紹一個(gè)參數(shù)的情況，單個(gè)參數(shù)接受的參數(shù)類型為Collector，Collectors 類實(shí)現(xiàn)了很多歸約操作

List<Integer> integerList = Arrays.asList(2,4,1,3);List<Integer> integers = integerList.stream().filter(s -> s > 1).collect(Collectors.toList());System.out.println(integers.toString());

此處統(tǒng)計(jì)集合中大于1的元素并最終返回list。

min:獲取集合中最小值。

List<Integer> integerList = Arrays.asList(2,4,1,3);Integer min = integerList.stream().min(Integer::compareTo).get();System.out.println(min);

max：獲取集合中最大值。

List<Integer> integerList = Arrays.asList(2,4,1,3);Integer max = integerList.stream().max(Integer::compareTo).get();System.out.println(max);

count：獲取集合中元素個(gè)數(shù)

List<Integer> integerList = Arrays.asList(2,4,1,3);

long count = integerList.stream().count();System.out.println(count);

到此這篇關(guān)于Java入門到精通的學(xué)習(xí)筆記：零基礎(chǔ)如何快速學(xué)會(huì)Java開發(fā)的文章就介紹到這了,更多相關(guān)Java實(shí)用學(xué)習(xí)筆記內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！