java構(gòu)建Stream流的多種方式總結(jié)

更新時間：2023年11月05日 14:05:30 作者：IT小輝同學(xué)

Java?8引入了Stream流作為一項新的特性,它是用來處理集合數(shù)據(jù)的一種函數(shù)式編程方式,本文為大家整理了多種java構(gòu)建Stream流的方式,希望對大家有所幫助

流的創(chuàng)建：可以從集合、數(shù)組、I/O通道等多種數(shù)據(jù)源創(chuàng)建Stream流。例如，使用Collection.stream()方法可以將集合轉(zhuǎn)換為流，使用Arrays.stream()可以將數(shù)組轉(zhuǎn)換為流。
中間操作：Stream流支持各種中間操作，這些操作允許對流中的元素進行過濾、映射、排序等操作，而不會修改原始數(shù)據(jù)。一些常見的中間操作包括filter（過濾元素）、map（映射元素）、sorted（排序元素）等。
終端操作：終端操作是對流進行最終操作，它們觸發(fā)實際的計算并生成結(jié)果。一些常見的終端操作包括forEach（遍歷元素并執(zhí)行操作）、collect（將流中的元素收集到一個集合中）、count（計算元素個數(shù)）等。
延遲執(zhí)行：Stream操作是延遲執(zhí)行的，這意味著中間操作可以在不實際計算的情況下鏈接在一起。只有在調(diào)用終端操作時，才會觸發(fā)流的處理。
并行處理：Stream流支持并行處理，通過使用parallelStream()方法，可以輕松地將流的處理分布到多個處理器核心上，以提高性能。
函數(shù)式編程風(fēng)格：Stream流鼓勵使用函數(shù)式編程風(fēng)格，其中操作是以lambda表達式的形式傳遞的，使代碼更具表達力和簡潔。

以下是一個示例，演示了如何使用Stream流來操作一個集合：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

int sum = numbers.stream()
                .filter(n -> n % 2 == 0) // 過濾偶數(shù)
                .map(n -> n * 2) // 將偶數(shù)翻倍
                .reduce(0, Integer::sum); // 求和

System.out.println("偶數(shù)的翻倍之和為: " + sum);

這只是Stream流的一個簡單示例，它展示了Stream流的一些常見操作，如過濾、映射和匯總。通過Stream流，可以以更簡潔和可讀的方式處理集合數(shù)據(jù)，減少了樣板代碼，提高了代碼質(zhì)量和可維護性。下面我們將對構(gòu)建流的多種方式多種方式展開做一個詳細闡述。

1.從集合創(chuàng)建流

從集合創(chuàng)建Stream流非常簡單，可以使用集合類的stream()方法來獲取一個Stream對象。下面我將展示如何從集合創(chuàng)建Stream，并結(jié)合實際應(yīng)用提供兩個代碼示例。

示例1：從List創(chuàng)建Stream

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamCreationExample {

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

        // 創(chuàng)建一個Stream流
        Stream<String> nameStream = names.stream();

        // 使用Stream流進行操作
        nameStream
            .filter(name -> name.startsWith("A"))
            .forEach(System.out::println);
    }
}

這個示例中，我們首先創(chuàng)建了一個包含一些姓名的List集合，然后使用names.stream()方法創(chuàng)建了一個Stream流。接著，我們使用filter中間操作篩選出以"A"開頭的姓名，并使用forEach終端操作打印輸出結(jié)果。

示例2：從Map創(chuàng)建Stream

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class StreamCreationFromMapExample {

    public static void main(String[] args) {
        Map<Integer, String> studentMap = new HashMap<>();
        studentMap.put(1, "Alice");
        studentMap.put(2, "Bob");
        studentMap.put(3, "Charlie");
        studentMap.put(4, "David");
        studentMap.put(5, "Eve");

        // 從Map的鍵集合創(chuàng)建Stream
        Stream<Integer> studentIdsStream = studentMap.keySet().stream();

        // 使用Stream流進行操作
        studentIdsStream
            .filter(id -> id % 2 == 0)
            .forEach(id -> System.out.println(id + ": " + studentMap.get(id)));
    }
}

這個示例中，我們創(chuàng)建了一個包含學(xué)生ID和姓名的Map，然后使用studentMap.keySet().stream()方法從Map的鍵集合創(chuàng)建了一個Stream流。接著，我們使用filter中間操作篩選出偶數(shù)的學(xué)生ID，并使用forEach終端操作打印出相應(yīng)的學(xué)生信息。

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

從數(shù)組創(chuàng)建Stream流也非常簡單，Java 8 提供了Arrays.stream() 方法，它允許將一個數(shù)組轉(zhuǎn)換為一個Stream流。下面我將詳細介紹如何從數(shù)組創(chuàng)建Stream，并提供兩個代碼示例。

示例1：從整數(shù)數(shù)組創(chuàng)建Stream

import java.util.Arrays;
import java.util.stream.IntStream;

public class StreamCreationFromArrayExample {

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // 從整數(shù)數(shù)組創(chuàng)建IntStream
        IntStream numberStream = Arrays.stream(numbers);

        // 使用Stream流進行操作
        int sum = numberStream
            .filter(n -> n % 2 == 0)
            .map(n -> n * 2)
            .sum();

        System.out.println("偶數(shù)的翻倍之和為: " + sum);
    }
}

在這個示例中，我們首先創(chuàng)建了一個整數(shù)數(shù)組 numbers，然后使用 Arrays.stream(numbers) 方法將它轉(zhuǎn)換為一個 IntStream 流。接著，我們使用該流進行一系列操作，包括篩選出偶數(shù)并將其翻倍，最后計算它們的總和。

示例2：從字符串?dāng)?shù)組創(chuàng)建Stream

import java.util.Arrays;
import java.util.stream.Stream;

public class StreamCreationFromArrayExample {

    public static void main(String[] args) {
        String[] words = {"apple", "banana", "cherry", "date", "elderberry"};

        // 從字符串?dāng)?shù)組創(chuàng)建Stream
        Stream<String> wordStream = Arrays.stream(words);

        // 使用Stream流進行操作
        wordStream
            .filter(word -> word.startsWith("b"))
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

在這個示例中，我們創(chuàng)建了一個字符串?dāng)?shù)組 words，然后使用 Arrays.stream(words) 方法將它轉(zhuǎn)換為一個 Stream 流。接著，我們使用流進行操作，包括篩選出以字母 "b" 開頭的單詞，并將它們轉(zhuǎn)換為大寫形式后打印輸出。

3.靜態(tài)工廠方法

Java 8也引入了一些靜態(tài)工廠方法來創(chuàng)建Stream流，這些方法使得創(chuàng)建Stream流變得更加簡便和靈活。下面我將詳細介紹這些靜態(tài)工廠方法，并提供兩個代碼示例。

靜態(tài)工廠方法創(chuàng)建Stream

Stream.of(T... values)：通過將一個可變參數(shù)的元素列表傳遞給Stream.of方法來創(chuàng)建一個包含這些元素的Stream流。這對于創(chuàng)建具有少量元素的流非常方便。
Stream.empty()：使用Stream.empty()方法創(chuàng)建一個空的Stream流。
Stream.generate(Supplier<T> s)：通過提供一個Supplier函數(shù)來創(chuàng)建一個無限大小的Stream流，該函數(shù)會生成元素。通常，需要使用limit操作限制生成的元素數(shù)量。
Stream.iterate(T seed, UnaryOperator<T> f)：通過提供初始值（seed）和一個一元操作函數(shù)（UnaryOperator）來創(chuàng)建一個包含無限序列的Stream流。例如，可以使用Stream.iterate(0, n -> n + 1)來創(chuàng)建一個自然數(shù)序列的Stream流。

示例1：使用Stream.of創(chuàng)建Stream

import java.util.stream.Stream;

public class StreamFactoryExample {

    public static void main(String[] args) {
        // 使用Stream.of創(chuàng)建Stream流
        Stream<String> stream = Stream.of("Apple", "Banana", "Cherry", "Date");

        // 打印Stream中的元素
        stream.forEach(System.out::println);
    }
}

這個示例使用Stream.of靜態(tài)工廠方法創(chuàng)建了一個包含水果名稱的Stream流，并使用forEach終端操作打印出每個水果的名稱。

示例2：使用Stream.generate創(chuàng)建Stream

import java.util.Random;
import java.util.stream.Stream;

public class StreamGenerateExample {

    public static void main(String[] args) {
        // 使用Stream.generate創(chuàng)建隨機整數(shù)流
        Stream<Integer> randomIntStream = Stream.generate(() -> new Random().nextInt(100));

        // 限制流的元素數(shù)量，然后打印
        randomIntStream
            .limit(10)
            .forEach(System.out::println);
    }
}

在這個示例中，我們使用Stream.generate靜態(tài)工廠方法創(chuàng)建了一個包含隨機整數(shù)的Stream流。然后，我們使用limit操作限制了流中元素的數(shù)量，最后打印出了生成的隨機整數(shù)。

這些靜態(tài)工廠方法為創(chuàng)建不同類型的Stream提供了便捷的途徑，使流的創(chuàng)建更加靈活和便捷。

4.使用 Stream.Builder

Stream.Builder是Java 8引入的用于構(gòu)建流的一種方式。它允許逐個添加元素到流中，并最終構(gòu)建一個Stream對象。這對于在迭代或生成元素的過程中構(gòu)建流非常有用。

下面是如何使用Stream.Builder創(chuàng)建流的詳細介紹，并提供兩個代碼示例。

使用Stream.Builder創(chuàng)建流的步驟

創(chuàng)建Stream.Builder對象：首先，需要創(chuàng)建一個Stream.Builder對象。
添加元素：然后，使用Stream.Builder的add方法逐個添加元素到流中。
構(gòu)建流：一旦添加了所有元素，可以調(diào)用Stream.Builder的build方法來構(gòu)建Stream對象。

示例1：使用Stream.Builder創(chuàng)建流并過濾奇數(shù)

import java.util.stream.Stream;

public class StreamBuilderExample {

    public static void main(String[] args) {
        Stream.Builder<Integer> builder = Stream.builder();

        // 添加元素到Stream
        for (int i = 1; i <= 10; i++) {
            builder.accept(i);
        }

        // 構(gòu)建Stream
        Stream<Integer> numberStream = builder.build();

        // 使用Stream操作
        numberStream
            .filter(n -> n % 2 == 0) // 過濾偶數(shù)
            .forEach(System.out::println);
    }
}

在這個示例中，我們首先創(chuàng)建了一個Stream.Builder對象，然后使用accept方法逐個添加1到10的整數(shù)到流中，最后使用filter中間操作篩選出偶數(shù)并使用forEach終端操作打印出結(jié)果。

示例2：使用Stream.Builder生成斐波那契數(shù)列

import java.util.stream.Stream;

public class FibonacciStreamExample {

    public static void main(String[] args) {
        Stream.Builder<Long> builder = Stream.builder();

        long a = 0, b = 1;
        int count = 10;

        for (int i = 0; i < count; i++) {
            builder.accept(a);
            long next = a + b;
            a = b;
            b = next;
        }

        Stream<Long> fibonacciStream = builder.build();

        fibonacciStream.forEach(System.out::println);
    }
}

在這個示例中，我們使用Stream.Builder生成斐波那契數(shù)列的前10個數(shù)字。我們首先創(chuàng)建一個Stream.Builder對象，然后使用循環(huán)逐個添加斐波那契數(shù)列的元素，最后使用forEach終端操作打印出結(jié)果。

Stream.Builder適用于需要逐個生成元素并構(gòu)建流的情況，使代碼更加清晰和靈活。

5. 從文件創(chuàng)建流

在Java中，可以從文件創(chuàng)建Stream流以便進行文件的讀取和處理。通常，可以使用java.nio.file包中的類來實現(xiàn)這一目的。以下是如何從文件創(chuàng)建流的方法以及兩個代碼示例：

方法1：使用Files.lines方法創(chuàng)建文本文件的流

Files.lines方法允許創(chuàng)建一個包含文件內(nèi)容的Stream<String>，適用于文本文件的逐行讀取。該方法接受文件路徑作為參數(shù)，并返回一個Stream對象。

下面是一個示例：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileToStreamExample {

    public static void main(String[] args) {
        String filePath = "sample.txt"; // 文件路徑

        try (Stream<String> lines = Files.lines(Paths.get(filePath))) {
            lines.forEach(System.out::println); // 逐行打印文件內(nèi)容
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在這個示例中，我們使用Files.lines方法打開名為"sample.txt"的文本文件，并將其內(nèi)容逐行打印到控制臺。

方法2：使用Files.newInputStream方法創(chuàng)建二進制文件的流

如果要處理二進制文件，例如圖像或音頻文件，可以使用Files.newInputStream方法創(chuàng)建一個InputStream，然后將其轉(zhuǎn)換為Stream。下面是一個示例：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class BinaryFileToStreamExample {

    public static void main(String[] args) {
        String filePath = "image.jpg"; // 二進制文件路徑

        try {
            Path path = Paths.get(filePath);
            Stream<Byte> byteStream = Files.newInputStream(path)
                                          .map(b -> (byte) b);

            byteStream.forEach(System.out::println); // 逐字節(jié)打印二進制文件內(nèi)容
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在這個示例中，我們使用Files.newInputStream方法創(chuàng)建一個輸入流，然后將其映射為Stream<Byte>，并最終逐字節(jié)打印二進制文件的內(nèi)容。

無論是文本文件還是二進制文件，從文件創(chuàng)建Stream流都是非常有用的，它使文件的讀取和處理變得更加方便和靈活。在處理文件時，不要忘記適當(dāng)?shù)靥幚砜赡艹霈F(xiàn)的IOException異常。

以上就是java構(gòu)建Stream流的多種方式總結(jié)的詳細內(nèi)容，更多關(guān)于java構(gòu)建Stream流的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: