1.Stream API 介紹

Java8 版本引入的重要特性之一, 對于集合（例如 List、Map、Set 等）進行處理和操作的高級抽象.Stream API 提供了一種更為簡潔高效的的方式來處理集合數(shù)據(jù), 可讀性較高, 特別在數(shù)據(jù)的過濾、轉(zhuǎn)換、聚合時的操作很簡單方便快捷.

1.1 特點與優(yōu)勢

• 函數(shù)式風格: Stream API使用函數(shù)式接口和Lambda表達式, 讓代碼更具表達力和簡潔性.
• 惰性求值: Stream操作通常是惰性求值的, 這意味著在終端操作之前, 中間操作不會立即執(zhí)行, 從而提高了效率.
• 并行處理: 通過Stream API可以方便地實現(xiàn)并行處理, 從而充分利用多核處理器的優(yōu)勢, 加速處理大量數(shù)據(jù)的過程.

下面根據(jù)一些實際應(yīng)用場景來分析

1.2 兩大類型

• 中間操作(Intermediate Operations):中間操作是指在Stream上執(zhí)行的操作, 它們返回一個新的Stream, 允許你鏈式地進行多個中間操作.
• 終端操作(Terminal Operations):對Stream進行最終處理的操作, 當調(diào)用終端操作時, Stream會開始執(zhí)行中間操作, 并生成最終的結(jié)果或副作用.終端操作是Stream的"觸發(fā)器", 一旦調(diào)用終端操作, Stream就不能再被使用, 也不能再進行中間操作.

2.Stream API 中間操作

2.1 filter(條件)

用于根據(jù)指定條件過濾元素.它接收一個條件作為參數(shù), 只保留滿足條件的元素, 并生成一個新的Stream.

示例:

存在一個姓名的集合，現(xiàn)在要過濾出來名字中帶【大】的人員.

public static void main(String[] args) {
	List<String> tempList = Arrays.asList("劉一手", "杜子騰", "林大蛋", "Ekko");
	List<String> resList = tempList.stream()
	        .filter(s -> s.contains("大"))
	        .collect(Collectors.toList());
	System.out.println(resList.toString());
}

輸出:

[林大蛋]

這段Java代碼展示了如何使用Java Stream API對一個字符串列表進行處理，并篩選出包含字符"大"的字符串，然后將篩選后的結(jié)果收集到一個新的列表中，最后輸出結(jié)果。 讓我們逐步解釋這段代碼： 首先我們創(chuàng)建了一個包含四個字符串的集合，后使用 Stream API 對 tempList 進行處理。

首先，通過調(diào)用stream()方法，將tempList轉(zhuǎn)換為一個Stream。

接著，使用filter中間操作篩選出包含字符"大"的字符串。 這里的filter方法接收一個Lambda表達式作為參數(shù)，Lambda 表達式 s -> s.contains("大")用于判斷字符串是否包含字符"大"。

只有滿足條件的字符串會被保留在Stream中。 collect(Collectors.toList())這部分是終端操作，它將Stream中的元素收集到一個新的列表中。在這里，我們使用Collectors.toList()方法來將Stream中的篩選結(jié)果收集到一個新的List中，賦值給resList。

2.2 map(函數(shù))

用于對每個元素執(zhí)行映射操作, 將元素轉(zhuǎn)換成另一種類型.它接收一個Function（映射函數(shù)）作為參數(shù), 對每個元素應(yīng)用該映射函數(shù), 并生成一個新的Stream. 示例:

存在一個姓名的集合，現(xiàn)在要給所有名字加上姓名的前綴.

public static void main(String[] args) {
	List<String> tempList = Arrays.asList("劉一手", "杜子騰", "林大蛋", "Ekko");
	List<String> resList = tempList.stream()
	        .map(s -> "姓名: " + s)
	        .collect(Collectors.toList());
	System.out.println(resList.toString());
}

輸出:

[姓名: 劉一手, 姓名: 杜子騰, 姓名: 林大蛋, 姓名: Ekko]

這段代碼的意思是創(chuàng)建一個姓名集合，通過stream()方法把集合轉(zhuǎn)換為 Stream 流,通過 map() 方法給每個集合中的值拼接字符串后,使用collect()方法把這些元素歸集到一個新的 List 集合并賦值給 resList.

這里的 .map(s -> "姓名: " + s)是簡寫,詳細的更容易理解的寫法如下:

.map(s -> { return "姓名: " + s; })

2.3 flatMap(函數(shù))

類似于map操作，但是 flatMap 操作可以將每個元素映射成一個 Stream，然后把所有生成的 Stream 合并成一個新的Stream。

示例:

新建一個靜態(tài)內(nèi)部類, 然后聚合類中的集合數(shù)據(jù)

@Data
static class Personnel {
    // 人員姓名
    private String name;
    // 人員標簽
    private List<String> tagList;
    public Personnel(String name, List<String> tagList) {
        this.name = name;
        this.tagList = tagList;
    }
}

Tips: 就現(xiàn)在想要把 List<Personnel> 中的 tagList 聚合后進行處理, 代碼如下:

public static void main(String[] args) {
    Personnel personA = new Personnel("張三", Arrays.asList("抽煙", "喝酒", "燙頭"));
    Personnel personB = new Personnel("李斯", Arrays.asList("編碼", "喝酒", "踢足球"));
    List<Personnel> personnelList = Arrays.asList(personA, personB);
    personnelList.stream()
            .flatMap(p -> p.getTagList().stream())
            .forEach(s -> System.out.print(s + " "));
}

輸出:

抽煙 喝酒 燙頭 編碼 喝酒 踢足球

2.4 sorted()

用于對Stream中的元素進行排序，默認按照自然順序進行排序。也可以傳入自定義的Comparator來指定排序規(guī)則。

示例：

public class SortedTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(10, 20, 18, 300, 30, 2);
        // ① 默認排序
        List<Integer> orderList = numList.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.printf("① 默認排序: %s%n", orderList);
        // ② 自定義排序
        List<Integer> orderDescList = numList.stream()
                .sorted((x, y) -> {
                    return y.compareTo(x);
                })
                .collect(Collectors.toList());
        System.out.printf("② 自定義排序: %s%n", orderDescList);
    }
}

輸出：

① 默認排序: [2, 10, 18, 20, 30, 300]
② 自定義排序: [300, 30, 20, 18, 10, 2]

關(guān)于 return y.compareTo(x); 這塊的具體意義，可以自行搜索 compareTo 方法了解下，這里不做單獨贅述

2.5 distinct()

用于去除 Stream 中重復(fù)的元素，確保最終的 Stream 中每個元素都是唯一的。

示例：

public class DistinctStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(1,1,1,1,2,3,2,2);
        List<Integer> distinctList = numList.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(distinctList);
    }
}

輸出：

[1, 2, 3]

這段代碼先創(chuàng)建了一個數(shù)字集合，接下來使用 stream() 方法轉(zhuǎn)化為 Stream 流 使用 distinct() 方法對流中的元素進行去重，返回一個不包含重復(fù)元素的Stream 流 最后使用 collect() 方法對去重后的流轉(zhuǎn)換成一個新的 List 集合。

2.6 limit(long n)

用于限制Stream的大小，返回一個最大包含前n個元素的新Stream。

示例：

public class LimitStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(1,2,3,4,5,6,7,8);
        List<Integer> limitList = numList.stream()
                .limit(4)
                .collect(Collectors.toList());
        System.out.println(limitList);
    }
}

這段代碼創(chuàng)建一個包含整數(shù)的List集合numList，使用Stream API的limit(4)方法將集合截取為只包含前4個元素的新List集合，并將結(jié)果輸出到控制臺。

輸出結(jié)果為：

[1, 2, 3, 4]

2.7 skip(long n)

用于跳過Stream中的前n個元素，返回一個丟棄了前n個元素后剩余元素的新Stream。

示例：

public class SkipStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        List<Integer> skipList = numList.stream()
                .skip(numList.size() - 2)
                .collect(Collectors.toList());
        System.out.println(skipList);
    }
}

這段代碼創(chuàng)建一個包含整數(shù)的List集合numList，使用Stream API的 skip 方法將集合截取跳過前 集合大小-2個元素的新List集合，并將結(jié)果輸出到控制臺。

輸出結(jié)果為：

[7, 8]

2.8 peek(Consumer)

用于對每個元素執(zhí)行一個操作，同時保持Stream的流。它可以用于調(diào)試或記錄Stream中的元素。

示例：

public class PeekStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(5, 6, 7, 8);
        List<Integer> resList = numList.stream()
                .peek(System.out::println)
                .filter(s -> s == 5)
                .peek(s -> System.out.printf("過濾后的:%d%n", s))
                .collect(Collectors.toList());
    }
}

輸出:

5
過濾后的:5
6
7
8

這段代碼創(chuàng)建一個包含整數(shù)的List集合numList，使用Stream API的 peek 方法記錄初始的值，通過中間操作 filter 方法過濾值為 5 的后，再次通過peek 方法來打印并驗證我們的表達式后，把過濾后的結(jié)果通過 collect 方法生成一個新的 List 集合。

3.終端操作

在Java Stream API中，終端操作（Terminal Operations）是對Stream進行最終處理的操作。當調(diào)用終端操作時，Stream會開始執(zhí)行中間操作，并生成最終的結(jié)果或副作用。終端操作是Stream的觸發(fā)器，一旦調(diào)用終端操作，Stream就不能再被使用，也不能再進行中間操作。

以下是一些常見的Stream API終端操作：

3.1 forEach(Consumer)

對Stream中的每個元素執(zhí)行指定的操作，接收一個Consumer（消費者函數(shù)）作為參數(shù)。它通常用于對Stream中的元素進行輸出或執(zhí)行某些操作，但不會返回任何結(jié)果。

示例: 遍歷輸出中間操作后的集合

public class ForEachStreamTest {
    public static void main(String[] args) {
        // 給公司工資普漲 500
        List<Integer> salaryList = Arrays.asList(12000, 20000, 30000, 4000);
        salaryList.stream()
                .peek(s -> System.out.print("工資普漲前:" + s))
                .map(s -> s + 500)
                .forEach(s -> {
                    System.out.println("--工資普漲后:" + s);
                });
    }
}

以上代碼的含義是,創(chuàng)建一個工資集合,通過 stream() 方法轉(zhuǎn)換為 Stream 流,通過中間操作 peek() 方法記錄轉(zhuǎn)換前的元素值,后通過 map() 方法給元素進行轉(zhuǎn)換操作,最后通過終端操作 forEach() 方法進行遍歷.

輸出:

工資普漲前:12000--工資普漲后:12500
工資普漲前:20000--工資普漲后:20500
工資普漲前:30000--工資普漲后:30500
工資普漲前:4000--工資普漲后:4500

3.2 collect(Collector)

用于將Stream中的元素收集到一個容器中，接收一個Collector（收集器）作為參數(shù)。它允許你在Stream中執(zhí)行各種集合操作，例如將元素收集到List、Set、Map等容器中。

示例: 把 User 實體集合轉(zhuǎn)換為 Map 集合,名字作為 key,工資作為 Name

public class CollectStreamTest {
    public static void main(String[] args) {
        List<User> userList = Arrays.asList(new User("張三", 2000.5),
                new User("李斯", 11000.5),
                new User("王二", 12000.5),
                new User("張六", 32000.5),
                new User("趙公子", 1000000.0));
        Map<String, Double> userSalaryMap = userList.stream()
                .collect(Collectors.toMap(User::getName, User::getSalary));
        userSalaryMap.forEach((k, v) -> {
            System.out.printf("姓名:%s,工資:%.2f%n", k, v);
        });
    }
    @Data
    @AllArgsConstructor
    static class User {
        private String name;
        private Double salary;
    }
}

上述代碼的含義是創(chuàng)建一個人員集合,通過 stream() 轉(zhuǎn)換為 Stream 流,使用 collect() 方法把元素歸集, 利用 Collectors.toMap() 收集器轉(zhuǎn)換為 Map 后,內(nèi)部接收會遍歷每個元素,Collectors.toMap(User::getName, User::getSalary)是簡寫,詳細的寫法如下:

Collectors.toMap(s -> s.getName(), s -> s.getSalary())

輸出:

姓名:張三,工資:2000.50
姓名:趙公子,工資:1000000.00
姓名:張六,工資:32000.50
姓名:李斯,工資:11000.50
姓名:王二,工資:12000.50

3.3 toArray()

將Stream中的元素轉(zhuǎn)換成一個數(shù)組。返回一個包含所有元素的數(shù)組，返回的數(shù)組類型是根據(jù)流元素的類型自動推斷的。如果流是空的，將返回一個長度為0的數(shù)組。

示例:

public class ToArrayStreamTest {
    public static void main(String[] args) {
        // 示例整數(shù)流
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
        // 使用toArray()將流中的元素收集到一個數(shù)組中
        int[] intArray = intStream.toArray();
        // 輸出結(jié)果數(shù)組
        System.out.println(Arrays.toString(intArray));
    }
}

輸出:

[1, 2, 3, 4, 5]

在這個示例中，我們創(chuàng)建了一個整數(shù)流 IntStream，然后使用 toArray() 方法將流中的所有整數(shù)收集到一個數(shù)組中，并輸出結(jié)果數(shù)組。

3.4 reduce(BinaryOperator)

Stream 類的 reduce() 方法是用于將流中的元素進行歸約操作的方法。接收一個 BinaryOperator（二元運算函數(shù)作為參數(shù)，用于對兩個元素進行操作，并返回一個合并后的結(jié)果。它可以將流中的所有元素按照指定的規(guī)則進行合并，并返回一個 Optional 對象，因為流可能為空。

示例:

public class ReduceStreamTest {
    public static void main(String[] args) {
        // 示例整數(shù)流
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
        // 使用reduce()將流中的整數(shù)相加得到總和
        OptionalInt sumOptional = intStream.reduce((a, b) -> a + b);
        // 獲取結(jié)果總和，如果流為空，則給出一個默認值0
        int sum = sumOptional.orElse(0);
        // 輸出結(jié)果總和
        System.out.println("總和: " + sum);
    }
}

輸出:

總和: 15

上面的代碼中，我們創(chuàng)建了一個整數(shù)流 IntStream，然后使用 reduce() 方法將流中的整數(shù)相加得到總和。由于流中有元素，因此 reduce() 方法返回包含總和的 Optional 對象。我們使用 orElse(0) 獲取結(jié)果總和，防止流為空的情況。最后輸出得到的結(jié)果總和。

3.5 min(Comparator) / max(Comparator)

Stream 類的 min() 和 max() 方法是用于查找流中的最小值和最大值的終端操作。它們接受一個 Comparator 對象作為參數(shù)來確定元素的順序，并返回一個 Optional 對象，因為流可能為空。

以下是 min() 和 max() 方法的簡要解釋以及示例代碼：

min() 方法：

Optional<T> min(Comparator<? super T> comparator)

• 方法簽名：<T> Optional<T> min(Comparator<? super T> comparator)
• min() 方法用于查找流中的最小元素。
• comparator 參數(shù)用于確定元素的順序，以便找到最小值。
• 如果流為空，則返回一個空的 Optional 對象。

max() 方法：

Optional<T> max(Comparator<? super T> comparator)

• 方法簽名：<T> Optional<T> max(Comparator<? super T> comparator)
• max() 方法用于查找流中的最大元素。
• comparator 參數(shù)用于確定元素的順序，以便找到最大值。
• 如果流為空，則返回一個空的 Optional 對象。

示例：假設(shè)我們有一個包含整數(shù)的流，并且我們想找到其中的最小值和最大值

public class MinMaxStreamTest {
    public static void main(String[] args) {
        // 示例整數(shù)流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用min()找到最小值
        Optional<Integer> minOptional = integerStream.min(Integer::compareTo);
        if (minOptional.isPresent()) {
            System.out.println("最小值為: " + minOptional.get());
        } else {
            System.out.println("流為空.");
        }
        // 重新創(chuàng)建一個整數(shù)流，因為流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用max()找到最大值
        Optional<Integer> maxOptional = newIntegerStream.max(Integer::compareTo);
        if (maxOptional.isPresent()) {
            System.out.println("最大值為: " + maxOptional.get());
        } else {
            System.out.println("流為空.");
        }
    }
}

輸出:

最小值為: 1
最大值為: 8

上述代碼中，我們創(chuàng)建了一個整數(shù)流 Stream<Integer>，然后使用 min() 方法找到最小值，并使用 max() 方法找到最大值。我們使用 Optional 對象來處理可能為空的情況，并輸出找到的最小值和最大值。請注意，一旦流被消耗，就不能再次使用它，因此我們在找到最小值后重新創(chuàng)建了一個整數(shù)流來找到最大值。

3.6 count()

Stream 類的 count() 方法是用于計算流中元素個數(shù)的終端操作。它返回一個 long 類型的值，表示流中的元素數(shù)量。count() 方法是一個終端操作，一旦調(diào)用該方法，流就被消耗，無法再次使用。

示例: 有一個包含整數(shù)的流，并且我們想計算流中的元素個數(shù)

public class CountStreamTest {
    public static void main(String[] args) {
        // 示例整數(shù)流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用count()計算流中的元素個數(shù)
        long count = integerStream.count();
        // 輸出元素個數(shù)
        System.out.println("元素數(shù)量: " + count);
    }
}

輸出:

元素數(shù)量: 5

上述代碼中，我們創(chuàng)建了一個整數(shù)流 Stream<Integer>，然后使用 count() 方法計算流中的元素個數(shù)。由于這是一個終端操作，一旦調(diào)用了 count() 方法，流就會被消耗，不能再次使用。我們輸出計算得到的元素個數(shù)。

3.7 anyMatch(Predicate) / allMatch(Predicate) / noneMatch(Predicate)

Stream 類的 anyMatch(), allMatch(), 和 noneMatch() 是用于檢查流中元素是否滿足特定條件的終端操作。它們返回一個布爾值，表示流中的元素是否滿足指定的條件。這些方法在遇到滿足條件的元素后可能會提前終止流的處理。anyMatch檢查是否有任意元素滿足條件，allMatch檢查是否所有元素都滿足條件，noneMatch檢查是否沒有元素滿足條件。

以下是 anyMatch(), allMatch(), 和 noneMatch() 方法的簡要解釋以及示例代碼：

anyMatch() 方法：

boolean anyMatch(Predicate<? super T> predicate)

• 方法簽名：boolean anyMatch(Predicate<? super T> predicate)
• anyMatch() 方法用于檢查流中是否存在至少一個元素滿足給定的條件。
• 它接受一個 Predicate 參數(shù)，用于定義滿足條件的判斷規(guī)則。
• 如果流中至少有一個元素滿足條件，返回 true，否則返回 false。

allMatch() 方法：

boolean allMatch(Predicate<? super T> predicate)

• 方法簽名：boolean allMatch(Predicate<? super T> predicate)
• allMatch() 方法用于檢查流中的所有元素是否都滿足給定的條件。
• 它接受一個 Predicate 參數(shù)，用于定義滿足條件的判斷規(guī)則。
• 如果流中的所有元素都滿足條件，返回 true，否則返回 false。

noneMatch() 方法：

boolean noneMatch(Predicate<? super T> predicate)

• 方法簽名：boolean noneMatch(Predicate<? super T> predicate)
• noneMatch() 方法用于檢查流中是否所有元素都不滿足給定的條件。
• 它接受一個 Predicate 參數(shù)，用于定義滿足條件的判斷規(guī)則。
• 如果流中的所有元素都不滿足條件，返回 true，否則返回 false。

示例代碼：

假設(shè)我們有一個包含整數(shù)的流，并且我們想檢查流中是否存在某些元素滿足特定條件。

public class MatchStreamTest {
    public static void main(String[] args) {
        // 示例整數(shù)流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用anyMatch()檢查是否存在元素大于5
        boolean anyGreaterThan5 = integerStream.anyMatch(num -> num > 4);
        System.out.println("是否存在元素大于 5 ?" + anyGreaterThan5);
        // 重新創(chuàng)建一個整數(shù)流，因為流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用allMatch()檢查是否所有元素都小于10
        boolean allLessThan10 = newIntegerStream.allMatch(num -> num < 10);
        System.out.println("所有元素都小于10 ? " + allLessThan10);
        // 重新創(chuàng)建一個整數(shù)流，因為流已被消耗
        Stream<Integer> newestIntegerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用noneMatch()檢查是否沒有元素等于10
        boolean noneEqualTo10 = newestIntegerStream.noneMatch(num -> num == 10);
        System.out.println("是否沒有元素等于 10 ? " + noneEqualTo10);
    }
}

輸出：

是否存在元素大于 5 ?true
所有元素都小于10? true
是否沒有元素等于 10 ? true

上述代碼中，我們創(chuàng)建了一個整數(shù)流 Stream<Integer>，然后使用 anyMatch() 方法檢查是否存在元素大于5，使用 allMatch() 方法檢查是否所有元素都小于10，以及使用 noneMatch() 方法檢查是否沒有元素等于10。我們輸出檢查的結(jié)果。注意，在每次使用終端操作后，流就被消耗了，不能再次使用，因此在檢查不同條件時需要重新創(chuàng)建流。

3.8 findFirst() / findAny()

Stream 類的 findFirst() 和 findAny() 方法用于在流中查找元素的終端操作。它們都返回一個 Optional 對象，表示找到的元素或元素的可能性。在并行流中，findAny() 方法可能更快，因為它不一定要遍歷所有元素。在串行 Stream 中，findFirst()和 findAny() 返回的是相同的元素，在并行Stream中，findAny()返回的是最先找到的元素。

以下是 findFirst() 和 findAny() 方法的簡要解釋以及示例代碼：

findFirst() 方法：

Optional<T> findFirst()

• 方法簽名：Optional<T> findFirst()
• findFirst() 方法用于在流中查找第一個滿足條件的元素。
• 它返回一個 Optional 對象，表示找到的元素，如果流為空，則返回一個空的 Optional 對象。

findAny() 方法：

Optional<T> findAny()

• 方法簽名：Optional<T> findAny()
• findAny() 方法用于在流中查找任意一個滿足條件的元素。
• 它返回一個 Optional 對象，表示找到的元素，如果流為空，則返回一個空的 Optional 對象。
• 在并行流中，findAny() 方法可能比 findFirst() 方法更快，因為它不一定要遍歷所有元素。

示例代碼：

假設(shè)我們有一個包含整數(shù)的流，并且我們想查找其中的某個元素。

public class FindStreamTest {
    public static void main(String[] args) {
        // 示例整數(shù)流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用findFirst()找到第一個元素
        Optional<Integer> firstElementOptional = integerStream.findFirst();
        if (firstElementOptional.isPresent()) {
            System.out.println("發(fā)現(xiàn)第一個元素: " + firstElementOptional.get());
        } else {
            System.out.println("流為空!");
        }
        // 重新創(chuàng)建一個整數(shù)流，因為流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);
        // 使用findAny()找到任意一個元素
        Optional<Integer> anyElementOptional = newIntegerStream.findAny();
        if (anyElementOptional.isPresent()) {
            System.out.println("找到任意一個元素: " + anyElementOptional.get());
        } else {
            System.out.println("流為空!");
        }
    }
}

輸出（注意輸出的結(jié)果可能因為流的處理順序不同而有所變化）：

發(fā)現(xiàn)第一個元素: 1
找到任意一個元素: 1

上述代碼中，創(chuàng)建了整數(shù)流 Stream<Integer>，然后使用 findFirst() 方法找到第一個元素，使用 findAny() 方法找到任意一個元素，并輸出找到的元素。請注意，一旦調(diào)用了這些方法，流就被消耗了，不能再次使用。在并行流中，findAny() 方法可能比 findFirst() 方法更快，因為它不一定要遍歷所有元素。

以上就是Java Stream常用方法合集(超詳細)的詳細內(nèi)容，更多關(guān)于Java Stream常用方法的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論