一、關(guān)于java.util包

1.1簡介

java.util? 包是Java標(biāo)準(zhǔn)類庫中的一個非常重要的組成部分，它提供了一系列對程序開發(fā)非常有用的類和接口。這個包主要包含集合框架、日期時間類、事件模型、隨機數(shù)生成器以及其他實用工具類。

1.2常用類及接口

• 集合框架 - 集合框架是java.util?包中最重要的部分之一，它提供了一系列的數(shù)據(jù)結(jié)構(gòu)和算法，幫助開發(fā)者存儲和操作數(shù)據(jù)集合。

  • Collection? - 集合框架的根接口，代表一組對象，這些對象稱為元素。
  • List? - 有序集合，每個元素都有其在集合中的特定位置。
  • Set? - 不允許重復(fù)元素的集合。
  • Map? - 鍵值對的集合，也稱為字典或哈希表。
  • ArrayList? - 實現(xiàn)了List?接口的動態(tài)數(shù)組。
  • LinkedList? - 實現(xiàn)了List?接口的雙向鏈表。
  • HashSet? - 實現(xiàn)了Set?接口的哈希表集合。
  • LinkedHashSet? - 繼承自HashSet?，維護元素插入順序的集合。
  • TreeSet? - 實現(xiàn)了Set?接口的基于紅黑樹的集合，元素按自然順序或自定義順序排序。
  • HashMap? - 實現(xiàn)了Map?接口的哈希表。
  • LinkedHashMap? - 繼承自HashMap?，維護元素插入順序或訪問順序的映射。
  • TreeMap? - 實現(xiàn)了Map?接口的基于紅黑樹的映射，鍵按自然順序或自定義順序排序。

• 日期時間類 - 提供了操作日期和時間的類。

  • Date? - 表示特定的瞬間，精確到毫秒。
  • Calendar? - 可以用于日期的計算，比如添加或減少天數(shù)、獲取星期等。
  • TimeZone? - 表示時區(qū)。
  • Locale? - 表示特定的語言、國家和區(qū)域的設(shè)置。

• 事件模型 - 用于處理事件和監(jiān)聽器模式。

  • EventObject? - 所有事件的超類。
  • EventListener? - 所有事件監(jiān)聽器接口的標(biāo)記接口。
  • EventSource? - 能夠生成事件的對象。

• 隨機數(shù)生成器 - 提供隨機數(shù)生成的功能。

  • Random? - 基于線性同余生成器的隨機數(shù)生成器。
  • java.security.SecureRandom? - 提供更安全的隨機數(shù)生成。

• 其他實用工具類 - 提供了一系列靜態(tài)方法，用于執(zhí)行各種任務(wù)。

  • Arrays? - 提供靜態(tài)方法來操作數(shù)組，如排序、搜索等。
  • Collections? - 提供靜態(tài)方法來操作集合，如排序、搜索等。
  • Objects? - 提供靜態(tài)方法來操作對象，如空安全的比較、計算哈希碼等。
  • Timer? - 可以調(diào)度任務(wù)在將來的某個時間點執(zhí)行。
  • UUID? - 用于生成UUID（通用唯一標(biāo)識符）。

1.3時間

1.3.1Date類

簡介

java.util.Date? 類在Java中用于表示特定的瞬間，精確到毫秒。

構(gòu)造方法

Date類提供了多個構(gòu)造方法，其中比較常用的有：

• Date(): 創(chuàng)建一個表示當(dāng)前日期和時間的Date對象。
• Date(long date): 根據(jù)指定的毫秒數(shù)創(chuàng)建一個Date對象，該毫秒數(shù)表示自1970年1月1日00:00:00 GMT以來的毫秒數(shù)。

方法

• getTime(): 返回自1970年1月1日00:00:00 GMT以來的毫秒數(shù)。
• toString(): 將Date對象轉(zhuǎn)換為String類型。
• before(Date when): 比較兩個日期，如果當(dāng)前日期早于參數(shù)日期，則返回true。
• after(Date when): 比較兩個日期，如果當(dāng)前日期晚于參數(shù)日期，則返回true。

示例

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        // 創(chuàng)建表示當(dāng)前日期和時間的Date對象
        Date currentDate = new Date();
        System.out.println("當(dāng)前日期和時間：" + currentDate);

        // 創(chuàng)建一個指定日期和時間的Date對象
        Date specificDate = new Date(1630454400000L); // 對應(yīng)2022年9月2日12:00:00
        System.out.println("指定日期和時間：" + specificDate);

        // 判斷日期先后
        if (currentDate.after(specificDate)) {
            System.out.println("當(dāng)前日期晚于指定日期");
        } else {
            System.out.println("當(dāng)前日期早于指定日期");
        }
    }
}

1.3.2TimeZone類

簡介

在Java中，TimeZone類用于表示時區(qū)信息，并提供了對時區(qū)進行操作的方法。它可以幫助我們在處理日期和時間時，將時間轉(zhuǎn)換為特定時區(qū)下的時間，并進行時區(qū)之間的轉(zhuǎn)換。‍

構(gòu)造方法

TimeZone類是一個抽象類，不能直接實例化，但它提供了一些靜態(tài)方法來獲取TimeZone對象：

• getTimeZone(String ID): 返回指定ID對應(yīng)的TimeZone對象，例如：“GMT+08:00”。
• getDefault(): 返回默認的TimeZone對象，通常是系統(tǒng)默認的時區(qū)。

方法

TimeZone類提供了一些常用的方法，包括但不限于：

• getDisplayName(): 返回時區(qū)的名稱。
• getID(): 返回時區(qū)的ID。
• getOffset(long date): 返回指定日期的偏移量，單位為毫秒。
• inDaylightTime(Date date): 判斷指定日期是否在夏令時時段內(nèi)。
• getAvailableIDs(): 返回所有可用的時區(qū)ID數(shù)組。‍

示例

import java.util.Date;
import java.util.TimeZone;

public class Main {
    public static void main(String[] args) {
        // 獲取默認的時區(qū)
        TimeZone defaultTimeZone = TimeZone.getDefault();
        System.out.println("默認時區(qū)：" + defaultTimeZone.getDisplayName());

        // 獲取指定ID的時區(qū)
        TimeZone gmt8TimeZone = TimeZone.getTimeZone("GMT+08:00");
        System.out.println("GMT+08:00時區(qū)：" + gmt8TimeZone.getDisplayName());

        // 進行時區(qū)轉(zhuǎn)換
        Date currentDate = new Date();
        System.out.println("當(dāng)前日期和時間：" + currentDate);
        System.out.println("當(dāng)前日期和時間在GMT+08:00時區(qū)：" + formatDateInTimeZone(currentDate, gmt8TimeZone));
    }

    // 將日期轉(zhuǎn)換為指定時區(qū)下的日期
    private static Date formatDateInTimeZone(Date date, TimeZone timeZone) {
        long timeInUTC = date.getTime() - timeZone.getRawOffset();
        return new Date(timeInUTC);
    }
}

1.4集合框架

集合框架 - 集合框架是java.util?包中最重要的部分之一，它提供了一系列的數(shù)據(jù)結(jié)構(gòu)和算法，幫助開發(fā)者存儲和操作數(shù)據(jù)集合。

• Collection? - 集合框架的根接口，代表一組對象，這些對象稱為元素。
• List? - 有序集合，每個元素都有其在集合中的特定位置。
• Set? - 不允許重復(fù)元素的集合。
• Map? - 鍵值對的集合，也稱為字典或哈希表。
• ArrayList? - 實現(xiàn)了List?接口的動態(tài)數(shù)組。
• LinkedList? - 實現(xiàn)了List?接口的雙向鏈表。
• HashSet? - 實現(xiàn)了Set?接口的哈希表集合。
• LinkedHashSet? - 繼承自HashSet?，維護元素插入順序的集合。
• TreeSet? - 實現(xiàn)了Set?接口的基于紅黑樹的集合，元素按自然順序或自定義順序排序。
• HashMap? - 實現(xiàn)了Map?接口的哈希表。
• LinkedHashMap? - 繼承自HashMap?，維護元素插入順序或訪問順序的映射。
• TreeMap? - 實現(xiàn)了Map?接口的基于紅黑樹的映射，鍵按自然順序或自定義順序排序。

在之前章節(jié)有詳細介紹，這里不再贅述

1.5接口

1.5.1Comparator

簡介

java.util.Comparator? 接口是一個用于定義對象比較規(guī)則的接口。它允許開發(fā)者自定義對象比較邏輯，這在排序集合或者對對象進行排序操作時非常有用。Comparator? 接口提供了一種靈活的比較機制，使得可以對任何對象進行排序，而不僅僅是實現(xiàn)了特定比較方法的對象。‍

方法

• reversed(): 返回與當(dāng)前比較器相反的比較器（逆序排列）。

• thenComparing(): 返回一個復(fù)合比較器，用于對兩個對象進行多重比較。

• nullsFirst(): 返回一個可將null元素排在非null元素之前的比較器。

• nullsLast(): 返回一個可將null元素排在非null元素之后的比較器。

• compare(T o1, T o2) - 比較兩個對象 o1? 和 o2?。返回值是一個整數(shù)，它表示第一個參數(shù)相對于第二個參數(shù)是小于、等于還是大于：

  如果 o1? 小于 o2?，返回負整數(shù)；

  如果 o1? 等于 o2?，返回零；

  如果 o1? 大于 o2?，返回正整數(shù)。‍

示例

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student(1, "Alice"));
        studentList.add(new Student(2, "Bob"));
        studentList.add(new Student(3, "Charlie"));

        // 使用Comparator進行排序
        Collections.sort(studentList, Comparator.comparing(Student::getName));
  
        // 輸出排序后的結(jié)果
        for (Student student : studentList) {
            System.out.println("ID: " + student.getId() + ", Name: " + student.getName());
        }
    }
}

在這個示例中，首先定義了一個Student類，然后創(chuàng)建了一個包含Student對象的列表studentList。接著，我們使用Comparator.comparing方法根據(jù)學(xué)生姓名對列表進行排序，最終輸出排序后的結(jié)果。

1.5.2Iterator

簡介

在Java中，Iterator接口提供了一種用于遍歷集合元素的統(tǒng)一方式。通過實現(xiàn)Iterator接口，我們可以對集合中的元素進行迭代訪問，而不需要了解集合的具體實現(xiàn)方式。‍

方法

• boolean hasNext(): 如果仍有元素可以迭代，則返回true，否則返回false。
• E next(): 返回迭代的下一個元素。
• void remove(): 從迭代器指向的集合中移除迭代器最后返回的元素（可選操作）。‍

示例

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // 獲取Iterator對象并進行迭代
        Iterator<String> iterator = names.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            System.out.println(name);
        }
    }
}

在這個示例中，首先創(chuàng)建了一個包含字符串元素的ArrayList names。然后，我們通過調(diào)用names的iterator()方法獲得了一個Iterator對象，并使用while循環(huán)和next()方法對集合進行迭代訪問，最終輸出了每個元素的值。這種方式能夠適用于任何實現(xiàn)了Iterable接口的集合類，如List、Set等。‍

1.5.3EventListener

簡介

在Java中，EventListener接口是用于實現(xiàn)事件監(jiān)聽器的接口，用于處理各種類型的事件。通過實現(xiàn)EventListener接口，可以創(chuàng)建自定義的事件監(jiān)聽器，用于監(jiān)聽和響應(yīng)特定類型的事件。‍

方法

EventListener? 接口本身不定義任何方法，但是它有很多子接口，這些子接口定義了事件處理方法。例如：

• ActionListener?：用于處理動作事件，如按鈕點擊。
• ChangeListener?：用于監(jiān)聽 ChangeEvent?，當(dāng)事件源的狀態(tài)發(fā)生變化時觸發(fā)。
• MouseListener?：用于處理鼠標(biāo)事件，如鼠標(biāo)點擊、移動等。
• MouseMotionListener?：用于處理鼠標(biāo)移動和拖動事件。
• KeyListener?：用于處理鍵盤事件，如按鍵和釋放。‍

示例

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class MyMouseListener implements MouseListener {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("Mouse Clicked at: (" + e.getX() + ", " + e.getY() + ")");
    }

    @Override
    public void mousePressed(MouseEvent e) {
        // 實現(xiàn)鼠標(biāo)按下時的處理邏輯
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        // 實現(xiàn)鼠標(biāo)釋放時的處理邏輯
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        // 實現(xiàn)鼠標(biāo)進入組件時的處理邏輯
    }

    @Override
    public void mouseExited(MouseEvent e) {
        // 實現(xiàn)鼠標(biāo)退出組件時的處理邏輯
    }
}

在這個示例中，創(chuàng)建了一個名為MyMouseListener的類，實現(xiàn)了MouseListener接口，該接口定義了處理鼠標(biāo)事件的方法。我們重寫了MouseListener接口中的幾個方法，比如mouseClicked，在該方法中實現(xiàn)了鼠標(biāo)點擊事件發(fā)生時的邏輯。通過這種方式，我們可以自定義事件監(jiān)聽器來響應(yīng)特定的事件。

1.6工具類

1.6.1UUID類

簡介

java.util.UUID? 類是用于生成通用唯一標(biāo)識符（UUID）的工具類。UUID是一種標(biāo)準(zhǔn)化的32位字符格式，用于在分布式系統(tǒng)中唯一標(biāo)識信息。UUID的設(shè)計目的是在所有計算機和系統(tǒng)上都能生成高度唯一的標(biāo)識符，即使在不同的時間和空間中也是如此。‍

構(gòu)造方法

UUID類提供了兩種構(gòu)造方法：

• UUID(long mostSignificantBits, long leastSignificantBits): 使用指定的最高有效位和最低有效位創(chuàng)建一個UUID對象。
• UUID(String name): 根據(jù)指定的字符串名稱創(chuàng)建一個UUID對象。該字符串必須遵循UUID的標(biāo)準(zhǔn)格式，如 “550e8400-e29b-41d4-a716-446655440000”。
• UUID() - 生成一個隨機生成的UUID。

UUID randomUUID = new UUID();

方法

• static UUID randomUUID(): 靜態(tài)方法，用于生成一個隨機的UUID。
• String toString(): 將UUID轉(zhuǎn)換為字符串表示形式。
• int hashCode(): 返回此UUID的哈希碼值。
• boolean equals(Object obj): 比較兩個UUID對象是否相等。

示例

import java.util.UUID;

public class Main {
    public static void main(String[] args) {
        // 生成一個隨機的UUID
        UUID uuid = UUID.randomUUID();

        // 將UUID轉(zhuǎn)換為字符串表示形式
        String uuidString = uuid.toString();

        System.out.println("Random UUID: " + uuidString);
    }
}

在這個示例中，通過調(diào)用UUID.randomUUID()?方法生成一個隨機的UUID對象，然后通過調(diào)用toString()?方法將其轉(zhuǎn)換為字符串表示形式，并最終輸出到控制臺上。這樣我們就可以生成一個唯一的標(biāo)識符，用于在系統(tǒng)中標(biāo)識對象或?qū)嶓w。‍

1.6.2Random類

簡介

java.util.Random? 類是Java標(biāo)準(zhǔn)庫中提供的一個隨機數(shù)生成器。它用于生成偽隨機數(shù)流，這些隨機數(shù)在足夠長的時間內(nèi)看起來是隨機的，但實際上是可以重現(xiàn)的，因為它們是由一個初始種子值（seed）確定的。

構(gòu)造方法

• Random(): 創(chuàng)建一個新的隨機數(shù)生成器。
• Random(long seed): 使用指定的種子創(chuàng)建一個新的隨機數(shù)生成器。使用相同的種子創(chuàng)建的Random對象將生成相同的隨機數(shù)序列。‍

方法

• int nextInt(): 返回一個隨機的int值。
• int nextInt(int bound): 返回一個大于等于0且小于bound的隨機int值。
• double nextDouble(): 返回一個隨機的double值。
• void nextBytes(byte[] bytes): 生成隨機字節(jié)并將其放入提供的byte數(shù)組中。
• boolean nextBoolean(): 返回一個隨機的boolean值。‍

示例

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        // 使用默認構(gòu)造方法創(chuàng)建Random對象
        Random random = new Random();

        // 生成一個隨機整數(shù)
        int randomInt = random.nextInt();
        System.out.println("Random integer: " + randomInt);

        // 生成一個0到99之間的隨機整數(shù)
        int randomIntWithinRange = random.nextInt(100);
        System.out.println("Random integer within range (0-99): " + randomIntWithinRange);

        // 生成一個隨機double值
        double randomDouble = random.nextDouble();
        System.out.println("Random double: " + randomDouble);

        // 生成一個隨機float值
        float randomFloat = random.nextFloat();
        System.out.println("Random float: " + randomFloat);

        // 生成一個隨機long值
        long randomLong = random.nextLong();
        System.out.println("Random long: " + randomLong);

        // 生成一個隨機boolean值
        boolean randomBoolean = random.nextBoolean();
        System.out.println("Random boolean (true or false): " + randomBoolean);

        // 使用自定義種子值創(chuàng)建Random對象
        Random randomWithSeed = new Random(123456L);

        // 再次生成隨機整數(shù)，由于種子值相同，結(jié)果也將相同
        int sameRandomInt = randomWithSeed.nextInt();
        System.out.println("Same random integer with seed 123456: " + sameRandomInt);

        // 生成一個隨機高斯分布值
        double randomGaussian = random.nextGaussian();
        System.out.println("Random Gaussian (normal distribution) value: " + randomGaussian);
    }
}

在這個示例中，首先創(chuàng)建了一個默認的 Random? 對象，并使用它來生成不同類型的隨機數(shù)。 接著，我們創(chuàng)建了一個帶有自定義種子值的 Random? 對象，并展示了如何通過指定種子值來重現(xiàn)相同的隨機數(shù)序列。 最后，我們打印了生成的隨機數(shù)，展示了 Random? 類的各種用途。

1.6.3Scanner類

簡介

在Java中，Scanner類是用于讀取用戶輸入的一個方便的類，它可以從標(biāo)準(zhǔn)輸入流（如鍵盤輸入）、文件或字符串中獲取輸入數(shù)據(jù)。Scanner類提供了多種方法來解析基本數(shù)據(jù)類型和字符串。

構(gòu)造方法

• Scanner(InputStream source): 通過指定輸入流創(chuàng)建一個Scanner對象，通常用于從標(biāo)準(zhǔn)輸入流（System.in）讀取用戶輸入。
• Scanner(File source): 通過指定文件創(chuàng)建一個Scanner對象，用于從文件中讀取數(shù)據(jù)。
• Scanner(String source): 通過指定字符串創(chuàng)建一個Scanner對象，用于從字符串中讀取數(shù)據(jù)。‍

方法

• int nextInt(): 讀取下一個輸入項并將其解釋為int類型。
• double nextDouble(): 讀取下一個輸入項并將其解釋為double類型。
• String nextLine(): 讀取下一行輸入。
• boolean hasNext(): 檢查是否還有輸入項可讀。
• void close(): 關(guān)閉Scanner對象。‍

示例

import java.util.Scanner;

public class ScannerExample {
    public static void main(String[] args) {
        // 創(chuàng)建Scanner實例，使用System.in作為輸入源
        Scanner scanner = new Scanner(System.in);

        System.out.println("請輸入一個整數(shù)：");
        int integer = scanner.nextInt();
        System.out.println("您輸入的整數(shù)是：" + integer);

        System.out.println("請輸入一個浮點數(shù)：");
        double doubleValue = scanner.nextDouble();
        System.out.println("您輸入的浮點數(shù)是：" + doubleValue);

        System.out.println("請輸入一個布爾值（true/false）：");
        boolean booleanValue = scanner.nextBoolean();
        System.out.println("您輸入的布爾值是：" + booleanValue);

        System.out.println("請輸入一個字符串：");
        String string = scanner.nextLine();
        System.out.println("您輸入的字符串是：" + string);

        // 關(guān)閉Scanner實例
        scanner.close();
    }
}

在這個示例中，首先創(chuàng)建了一個 Scanner? 實例，它默認使用 System.in? 作為輸入源。 接著，我們使用 nextInt()?、nextDouble()?、nextBoolean()? 和 nextLine()? 方法從用戶那里讀取不同類型的輸入，并打印出來。 最后，我們調(diào)用 close()? 方法關(guān)閉 Scanner? 實例，釋放與它關(guān)聯(lián)的資源。‍

1.7java.util.concurrent包

1.7.1簡介

java.util.concurrent 包提供了在并發(fā)編程中使用的工具類和框架。它包含了一系列用于處理并發(fā)任務(wù)的實用工具，使得在多線程環(huán)境中編寫高效、安全的代碼變得更加簡單。

以下是 java.util.concurrent 包中一些常用的類和接口：

• Executor 框架：包括 Executor、ExecutorService 和 ScheduledExecutorService 接口，以及 Executors 工廠類。這些類允許你實現(xiàn)異步執(zhí)行任務(wù)和控制執(zhí)行過程。
• 線程安全集合：java.util.concurrent 包中提供了一系列線程安全的集合類，如 ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet 等。這些集合類能夠在多線程環(huán)境中安全地進行讀寫操作，避免了傳統(tǒng)集合類在并發(fā)情況下可能出現(xiàn)的線程安全問題。
• 同步器和鎖：該包中還包含了一些同步器和鎖的實現(xiàn)，如 ReentrantLock、ReadWriteLock、Condition 等，它們提供了更靈活的鎖機制，能夠滿足不同的并發(fā)控制需求。
• 并發(fā)工具類：java.util.concurrent 包還提供了一些并發(fā)編程中常用的工具類，比如 CountDownLatch、CyclicBarrier、Semaphore 等。這些工具類可以幫助協(xié)調(diào)多個線程之間的執(zhí)行順序和資源的訪問。

總的來說，java.util.concurrent 包為 Java 程序員提供了豐富的并發(fā)編程工具，幫助開發(fā)者更加輕松地處理多線程編程中的挑戰(zhàn)，提高了并發(fā)程序的性能和可靠性。通過合理地利用這些工具和框架，可以寫出高效、可靠的并發(fā)程序。

1.7.2CompletableFuture類

簡介

在Java中，CompletableFuture類提供了一種異步編程的方式，可以用于實現(xiàn)異步操作和構(gòu)建復(fù)雜的異步流水線。它是Java 8引入的一個重要特性，用于簡化并發(fā)編程。‍

java.util.concurrent 包中的 CompletableFuture 類是 Java 8 引入的一個類，用于支持異步編程和構(gòu)建異步操作鏈。CompletableFuture 提供了一種簡潔而強大的方式來處理異步任務(wù)的結(jié)果，以及對多個異步任務(wù)進行組合、串聯(lián)和并發(fā)控制。

以下是 CompletableFuture 類的一些主要特點和用法：

• 異步操作：CompletableFuture 可以表示一個異步計算的結(jié)果，通過 CompletableFuture 的方法可以注冊回調(diào)函數(shù)，在異步任務(wù)執(zhí)行完成后自動觸發(fā)回調(diào)函數(shù)處理結(jié)果。
• 組合操作：CompletableFuture 支持對多個 CompletableFuture 進行組合操作，包括 thenCombine、thenCompose、thenApplyAsync 等方法，可以串聯(lián)多個異步任務(wù)，形成復(fù)雜的異步操作鏈。
• 異常處理：CompletableFuture 允許你通過 exceptionally 或 handle 方法來處理異步任務(wù)中產(chǎn)生的異常，使得異常處理變得更加靈活。
• 并發(fā)控制：CompletableFuture 提供了一些方法來實現(xiàn)并發(fā)控制，比如 allOf、anyOf 等，能夠控制多個 CompletableFuture 的執(zhí)行順序和并發(fā)度。
• 超時處理：CompletableFuture 支持設(shè)置超時時間，并在超時時執(zhí)行特定的操作，避免任務(wù)長時間阻塞。

使用 CompletableFuture 可以簡化異步編程的復(fù)雜性，讓開發(fā)者能夠更加方便地處理異步任務(wù)的結(jié)果和操作。通過鏈?zhǔn)秸{(diào)用和組合不同的 CompletableFuture 對象，可以構(gòu)建出復(fù)雜的異步任務(wù)流水線，實現(xiàn)高效的并發(fā)編程。

總的來說，CompletableFuture 是 Java 中處理異步編程的重要工具，它提供了豐富的方法和功能，使得異步任務(wù)的管理和處理變得更加簡單和高效。‍

構(gòu)造方法

CompletableFuture類有多個靜態(tài)工廠方法來創(chuàng)建CompletableFuture對象，其中最常用的包括：

• static CompletableFuture<Void> runAsync(Runnable runnable): 異步執(zhí)行指定的Runnable任務(wù)，并返回一個CompletableFuture對象。
• static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier): 異步執(zhí)行指定的Supplier任務(wù)，并返回一個CompletableFuture對象，該任務(wù)產(chǎn)生一個結(jié)果。‍

方法

• CompletableFuture<T> thenApply(Function<? super T,? extends U> fn): 當(dāng)前CompletableFuture計算完成時，對其結(jié)果執(zhí)行給定的函數(shù)。
• CompletableFuture<T> thenCompose(Function<? super T,? extends CompletionStage<U>> fn): 當(dāng)前CompletableFuture計算完成時，對其結(jié)果執(zhí)行給定的函數(shù)，該函數(shù)返回另一個CompletableFuture。
• CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn): 當(dāng)當(dāng)前CompletableFuture計算完成或者拋出異常時，執(zhí)行給定的函數(shù)。
• static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs): 等待所有的CompletableFuture對象執(zhí)行完畢。

示例

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 創(chuàng)建一個CompletableFuture對象，異步執(zhí)行一個簡單的任務(wù)
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Async task running in the background...");
            try {
                Thread.sleep(2000); // 模擬耗時操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Async task completed.");
        });

        // 等待異步任務(wù)執(zhí)行完畢
        future.get(); // 這里會阻塞直到任務(wù)完成

        System.out.println("Main thread continues to run...");
    }
}

在這個示例中，首先使用CompletableFuture.runAsync()?方法創(chuàng)建了一個CompletableFuture對象，異步執(zhí)行一個簡單的任務(wù)。然后使用get()?方法等待異步任務(wù)執(zhí)行完畢。在主線程中，我們打印了一條消息表明主線程繼續(xù)執(zhí)行。這樣我們就可以利用CompletableFuture類方便地實現(xiàn)異步編程。‍

1.8java.util.stream?包

1.8.1簡介

java.util.stream? 包是 Java 8 引入的用于支持流式處理（Stream API）的包。該包提供了一組類和接口，用于對集合數(shù)據(jù)進行函數(shù)式操作，以實現(xiàn)更簡潔、可讀性更強的代碼。

以下是 java.util.stream? 包中一些常用的類和接口：

• Stream：Stream? 接口代表一個元素序列，可以支持各種操作來處理這個序列，如過濾、映射、歸約等。
• Collectors：Collectors? 類包含了一系列靜態(tài)工廠方法，用于生成常見的收集器實例，例如將流元素收集到列表、集合、映射等數(shù)據(jù)結(jié)構(gòu)中。
• IntStream, LongStream, DoubleStream：這些接口分別表示原始類型的流，提供了針對基本數(shù)據(jù)類型的特定操作。
• ParallelStream：ParallelStream? 類支持并行流操作，可以加速處理大量數(shù)據(jù)的操作。

通過使用 java.util.stream? 包中提供的類和接口，開發(fā)者可以利用流式處理來簡化集合數(shù)據(jù)的操作、提高代碼的可讀性，并且能夠更方便地進行并行處理以提升性能。這些功能使得 Java 編程變得更加靈活和強大。‍

1.8.2Collectors類

簡介

Collectors? 類是 Java 中 java.util.stream? 包中的一個工具類，提供了一系列靜態(tài)工廠方法，用于生成常見的收集器實例，以便在流式處理中對元素進行匯總和歸約操作。

通過 Collectors? 類，可以方便地將流中的元素收集到不同類型的數(shù)據(jù)結(jié)構(gòu)中，比如集合（List、Set）、映射（Map）、字符串（joining）、統(tǒng)計信息（summarizingInt、summarizingDouble 等）等。這些收集器可以幫助簡化代碼，并支持并行處理以提高性能。‍

構(gòu)造方法

在 Java 中，Collectors? 類是一個工具類，它提供了一系列靜態(tài)工廠方法來創(chuàng)建不同類型的收集器。因此，Collectors? 類并沒有公開的構(gòu)造方法。相反，它提供了諸如 toList()?、toSet()?、toMap()? 等靜態(tài)方法，用于創(chuàng)建對應(yīng)的收集器實例。

這些靜態(tài)方法返回的是 Collector? 接口的實例，Collector? 接口定義了用于執(zhí)行歸約操作的方式，并可用于對輸入的元素進行匯總。Collector? 接口中有幾個重要的方法，包括 supplier()?、accumulator()?、combiner()? 和 finisher()?，它們定義了收集器的行為和屬性。

因此，我們通常不需要直接構(gòu)造 Collectors? 類的實例，而是通過調(diào)用其提供的靜態(tài)工廠方法來獲取特定類型的收集器。這樣可以更方便地對流中的元素進行匯總和歸約操作。

方法

一些常用的 Collectors? 方法包括：

• toList(): 將流中的元素收集到一個 List 中。
• toSet(): 將流中的元素收集到一個 Set 中。
• toMap(keyMapper, valueMapper): 將流中的元素根據(jù) keyMapper 和 valueMapper 轉(zhuǎn)換為 Map。
• joining(): 將流中的元素連接成一個字符串。
• groupingBy(classifier): 根據(jù)分類函數(shù)對流中的元素進行分組。
• summarizingInt(), summarizingDouble(), summarizingLong(): 用于統(tǒng)計流中元素的匯總信息，如 count、sum、min、max、average 等。‍
• 將流中的元素收集到一個 List 中：

List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
List<String> collectedList = words.stream()
                                .collect(Collectors.toList());
System.out.println(collectedList);

• 將流中的元素連接成一個字符串：

List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
String concatenatedString = words.stream()
                                .collect(Collectors.joining(", "));
System.out.println(concatenatedString);

• 根據(jù)字符串長度將元素分組：

List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
Map<Integer, List<String>> groupedByLength = words.stream()
                                                .collect(Collectors.groupingBy(String::length));
System.out.println(groupedByLength);

• 計算元素的數(shù)量、總和、最小值、最大值和平均值：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = numbers.stream()
                                    .collect(Collectors.summarizingInt(Integer::intValue));
System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Min: " + stats.getMin());
System.out.println("Max: " + stats.getMax());
System.out.println("Average: " + stats.getAverage());

這些示例展示了如何使用 Collectors? 類中的一些常見方法來對流進行匯總操作。您可以根據(jù)具體的需求選擇合適的收集器，并結(jié)合流操作來實現(xiàn)各種數(shù)據(jù)處理功能。‍

示例

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 創(chuàng)建一個包含一些整數(shù)的List
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用Collectors.toList()方法將Stream中的元素收集到List中
        List<Integer> evenNumbers = numbers.stream()
                .filter(num -> num % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("Even numbers: " + evenNumbers);

        // 使用Collectors.toSet()方法將Stream中的元素收集到Set中
        Set<Integer> oddNumbers = numbers.stream()
                .filter(num -> num % 2 != 0)
                .collect(Collectors.toSet());
        System.out.println("Odd numbers: " + oddNumbers);

        // 使用Collectors.toMap()方法將Stream中的元素收集到Map中
        Map<Integer, String> numberMap = numbers.stream()
                .collect(Collectors.toMap(
                        num -> num,
                        num -> "Number: " + num
                ));
        System.out.println("Number map: " + numberMap);
    }
}

在這個示例中，首先創(chuàng)建了一個包含一些整數(shù)的List。然后使用Stream API對這個List進行操作，并利用Collectors?類的方法將Stream中的元素收集到不同的數(shù)據(jù)結(jié)構(gòu)中，包括List、Set和Map。最后我們打印出了收集到的結(jié)果。

1.8.3Stream類

簡介

在 Java 中，Stream 是 Java 8 引入的一個全新的抽象概念，它提供了一種高效且功能強大的數(shù)據(jù)處理方式。Stream 可以讓你以一種聲明式的方式處理集合數(shù)據(jù)，這種方式更加簡潔、靈活，并且可以充分利用多核處理器的優(yōu)勢。

簡單來說，Stream 提供了一種對集合進行批量操作的高級抽象，它可以讓你通過一系列的操作（如過濾、映射、排序、歸約等）來處理集合中的元素，而無需寫顯式的循環(huán)。‍

構(gòu)造方法

從集合創(chuàng)建

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream(); // 從List創(chuàng)建Stream
Stream<String> parallelStreamFromList = list.parallelStream(); // 從List創(chuàng)建并行Stream

從數(shù)組創(chuàng)建

String[] array = {"a", "b", "c"};
Stream<String> streamFromArray = Arrays.stream(array); // 從數(shù)組創(chuàng)建Stream

使用Stream.of()

Stream<String> streamOfElements = Stream.of("a", "b", "c"); // 使用Stream.of()創(chuàng)建Stream

使用Stream.iterate()

Stream<Integer> streamIterate = Stream.iterate(0, n -> n + 2).limit(5); // 使用Stream.iterate()創(chuàng)建Stream

使用Stream.generate()

Stream<Double> streamGenerate = Stream.generate(Math::random).limit(3); // 使用Stream.generate()創(chuàng)建Stream

方法

Stream 類提供了豐富的方法來支持對集合數(shù)據(jù)的高級操作，這些方法可以分為中間操作和終端操作兩種類型。中間操作用于構(gòu)建 Stream 流水線，而終端操作則觸發(fā)實際的處理過程并產(chǎn)生結(jié)果。以下是一些常用的 Stream 方法：

中間操作：

• filter(Predicate) ：根據(jù)給定的條件過濾元素。
• map(Function) ：將元素按照指定規(guī)則轉(zhuǎn)換。
• flatMap(Function) ：將流中的每個元素都轉(zhuǎn)換成另一個流，然后把所有流連接成一個流。
• distinct() ：去除流中重復(fù)的元素。
• sorted() ：對流進行排序。
• limit(long maxSize) ：截斷流，使其最多只包含指定數(shù)量的元素。
• skip(long n) ：跳過指定數(shù)量的元素，返回剩余的元素。

終端操作：

• forEach(Consumer) ：對流中的每個元素執(zhí)行指定操作。
• collect(Collector) ：將流中的元素累積成一個結(jié)果容器，如 List、Map 等。
• reduce(BinaryOperator) ：用指定的二元運算符對流中的元素進行歸約操作，得到一個最終結(jié)果。
• count() ：返回流中元素的總個數(shù)。
• anyMatch(Predicate) ：檢查流中是否至少有一個元素滿足給定條件。
• allMatch(Predicate) ：檢查流中是否所有元素都滿足給定條件。
• noneMatch(Predicate) ：檢查流中是否沒有元素滿足給定條件。
• findFirst() ：返回流中的第一個元素。
• findAny() ：返回流中的任意一個元素。

除了上述方法之外，Stream 還提供了很多其他的操作，這些方法可以根據(jù)具體的需求進行組合和使用，以實現(xiàn)對集合數(shù)據(jù)的靈活處理。

示例

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Emma");

        // 創(chuàng)建一個 Stream 對象，并通過 filter 操作篩選出包含字母“a”的名字
        names.stream()
             .filter(name -> name.contains("a"))
             .forEach(System.out::println);
    }
}

在這個示例中，首先創(chuàng)建了一個包含幾個名字的 List。然后使用 stream()? 方法將其轉(zhuǎn)換為 Stream 對象，在 Stream 上調(diào)用 filter? 方法，傳入一個 Lambda 表達式作為條件，篩選出包含字母“a”的名字。最后，我們使用 forEach? 方法打印篩選出的結(jié)果。

除了 filter? 和 forEach? 操作之外，Stream 還提供了很多其他的操作，如 map?、reduce?、sorted? 等，通過這些操作，可以非常方便地進行數(shù)據(jù)處理和轉(zhuǎn)換。

需要注意的是，Stream 的操作通常是惰性求值的，也就是說，在調(diào)用終結(jié)操作（如 forEach?）之前，中間操作（如 filter?、map?）不會立即執(zhí)行，而是等到終結(jié)操作觸發(fā)時才會執(zhí)行。這種特性使得 Stream 在處理大規(guī)模數(shù)據(jù)時更加高效。

總結(jié)

到此這篇關(guān)于Java學(xué)習(xí)常用包(類)之java.util包詳解的文章就介紹到這了,更多相關(guān)Java java.util包內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論