摘要

Java 8 中创建 Stream 的 10 种常见方式。，示例中的元素采用 A, B, C，输出均已在注释中标明。

---

目录

1. Stream.of（可变参数）
2. Stream.of（传入数组）
3. Arrays.stream
4. List 的 stream()
5. Set 的 stream()（保持插入顺序）
6. Map.values().stream()（按值创建）
7. Stream.iterate（迭代生成）
8. Pattern.splitAsStream（按正则分割）
9. Files.lines（按行读取文件）
10. Stream.generate（凭 Supplier 生成）

1. Stream.of（可变参数）

适合少量已知元素。

public static void example1_StreamOfVarargs() {
    Stream<String> stream1 = Stream.of("A", "B", "C");
    System.out.println("stream1:" + stream1.collect(joining()));
    // 预期输出： stream1:ABC
}

---

2. Stream.of（传入数组）

把数组作为参数传入 Stream.of。

public static void example2_StreamOfArray() {
    String[] values = new String[]{"A", "B", "C"};
    Stream<String> stream2 = Stream.of(values);
    System.out.println("stream2:" + stream2.collect(joining()));
    // 预期输出： stream2:ABC
}

---

3. Arrays.stream

直接使用 Arrays.stream 创建数组流。

public static void example3_ArraysStream() {
    String[] values = new String[]{"A", "B", "C"};
    Stream<String> stream3 = Arrays.stream(values);
    System.out.println("stream3:" + stream3.collect(joining()));
    // 预期输出： stream3:ABC
}

---

4. List 的 stream()

从 List 获取流是最常见的来源之一。

public static void example4_ListStream() {
    List<String> list = Arrays.asList("A", "B", "C");
    Stream<String> stream4 = list.stream();
    System.out.println("stream4:" + stream4.collect(joining()));
    // 预期输出： stream4:ABC
}

---

5. Set 的 stream()（使用 LinkedHashSet 保持插入顺序）

public static void example5_SetStream() {
    Set<String> set = new LinkedHashSet<>(Arrays.asList("A", "B", "C"));
    Stream<String> stream5 = set.stream();
    System.out.println("stream5:" + stream5.collect(joining()));
    // 预期输出： stream5:ABC
}

---

6. Map.values().stream()（使用 LinkedHashMap 保持顺序）

对 Map 的值创建流，若希望保持插入顺序可使用 LinkedHashMap。

public static void example6_MapValuesStream() {
    Map<String, String> map = new LinkedHashMap<>();
    map.put("1", "A");
    map.put("2", "B");
    map.put("3", "C");
    Stream<String> stream6 = map.values().stream();
    System.out.println("stream6:" + stream6.collect(joining()));
    // 预期输出： stream6:ABC
}

---

7. Stream.iterate（迭代生成序列）

使用 iterate 生成由前一项推导下一项的序列，Java 8 常配合 limit() 使用以避免无限流。

public static void example7_StreamIterate() {
    Stream<String> stream7 = Stream.iterate("A", e -> String.valueOf((char)(e.charAt(0) + 1)))
                                   .limit(3);
    System.out.println("stream7:" + stream7.collect(joining()));
    // 预期输出： stream7:ABC
}

---

8. Pattern.splitAsStream（按正则分割）

把字符串按正则分割并直接得到流：

public static void example8_PatternSplitAsStream() {
    String value = "A B C";
    Stream<String> stream8 = Pattern.compile("\\s+").splitAsStream(value);
    System.out.println("stream8:" + stream8.collect(joining()));
    // 预期输出： stream8:ABC
}

---

9. Files.lines（按行读取文件）

从文件按行读取并生成流，示例会临时创建文件写入 A/B/C 再读取，便于直接运行验证。

public static void example9_FilesLines() {
    Path tempFile = null;
    try {
        tempFile = Files.createTempFile("stream_demo_", ".txt");
        Files.write(tempFile, Arrays.asList("A", "B", "C"), StandardCharsets.UTF_8);
        try (Stream<String> stream9 = Files.lines(tempFile, StandardCharsets.UTF_8)) {
            System.out.println("stream9:" + stream9.collect(joining()));
            // 预期输出： stream9:ABC
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (tempFile != null) {
            try { Files.deleteIfExists(tempFile); } catch (IOException ignored) {}
        }
    }
}

---

10. Stream.generate（凭 Supplier 生成）

使用 Supplier 不断产生元素，也是一个无限流，需要配合 limit。

public static void example10_StreamGenerate() {
    Stream<String> stream10 = Stream.generate(() -> "A").limit(3);
    System.out.println("stream10:" + stream10.collect(joining()));
    // 预期输出： stream10:AAA
}

---

完整可运行类

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.*;

import static java.util.stream.Collectors.joining;

public class StreamCreationExamplesFull {
    public static void main(String[] args) {
        example1_StreamOfVarargs();
        example2_StreamOfArray();
        example3_ArraysStream();
        example4_ListStream();
        example5_SetStream();
        example6_MapValuesStream();
        example7_StreamIterate();
        example8_PatternSplitAsStream();
        example9_FilesLines();
        example10_StreamGenerate();
    }

    public static void example1_StreamOfVarargs() {
        Stream<String> stream1 = Stream.of("A", "B", "C");
        System.out.println("stream1:" + stream1.collect(joining()));
    }

    public static void example2_StreamOfArray() {
        String[] values = new String[]{"A", "B", "C"};
        Stream<String> stream2 = Stream.of(values);
        System.out.println("stream2:" + stream2.collect(joining()));
    }

    public static void example3_ArraysStream() {
        String[] values = new String[]{"A", "B", "C"};
        Stream<String> stream3 = Arrays.stream(values);
        System.out.println("stream3:" + stream3.collect(joining()));
    }

    public static void example4_ListStream() {
        List<String> list = Arrays.asList("A", "B", "C");
        Stream<String> stream4 = list.stream();
        System.out.println("stream4:" + stream4.collect(joining()));
    }

    public static void example5_SetStream() {
        Set<String> set = new LinkedHashSet<>(Arrays.asList("A", "B", "C"));
        Stream<String> stream5 = set.stream();
        System.out.println("stream5:" + stream5.collect(joining()));
    }

    public static void example6_MapValuesStream() {
        Map<String, String> map = new LinkedHashMap<>();
        map.put("1", "A");
        map.put("2", "B");
        map.put("3", "C");
        Stream<String> stream6 = map.values().stream();
        System.out.println("stream6:" + stream6.collect(joining()));
    }

    public static void example7_StreamIterate() {
        Stream<String> stream7 = Stream.iterate("A", e -> String.valueOf((char)(e.charAt(0) + 1)))
                                       .limit(3);
        System.out.println("stream7:" + stream7.collect(joining()));
    }

    public static void example8_PatternSplitAsStream() {
        String value = "A B C";
        Stream<String> stream8 = Pattern.compile("\\s+").splitAsStream(value);
        System.out.println("stream8:" + stream8.collect(joining()));
    }

    public static void example9_FilesLines() {
        Path tempFile = null;
        try {
            tempFile = Files.createTempFile("stream_demo_", ".txt");
            Files.write(tempFile, Arrays.asList("A", "B", "C"), StandardCharsets.UTF_8);
            try (Stream<String> stream9 = Files.lines(tempFile, StandardCharsets.UTF_8)) {
                System.out.println("stream9:" + stream9.collect(joining()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (tempFile != null) {
                try { Files.deleteIfExists(tempFile); } catch (IOException ignored) {}
            }
        }
    }

    public static void example10_StreamGenerate() {
        Stream<String> stream10 = Stream.generate(() -> "A").limit(3);
        System.out.println("stream10:" + stream10.collect(joining()));
    }
}