Java8 Stream流：Stream流的思想和获取Stream流

Stream流的思想

Stream流是Java 8引入的一种处理集合数据的抽象概念，其核心思想是将数据源（如集合、数组等）转化为流，通过链式调用一系列中间操作（如过滤、映射、排序等）对数据进行处理，最后通过终端操作（如收集、计数等）生成结果。Stream流强调函数式编程和惰性求值，能够高效、简洁地处理数据。

获取Stream流的方法

单列集合获取Stream流

单列集合（如List、Set）可以直接调用stream()方法获取流。

List<String> list = Arrays.asList("Java", "Python", "C++");
Stream<String> stream = list.stream();

实例：

public class StreamDemo2 {
    public static void main(String[] args) {
/*
        单列集合      default Stream<E> stream()                           Collection中的默认方法
        双列集合      无                                                   无法直接使用stream流
        数组          public static <T> Stream<T> stream(T[] array)        Arrays工具类中的静态方法
        一堆零散数据   public static<T> Stream<T> of(T... values)           Stream接口中的静态方法
*/

        //1.单列集合获取Stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");
        /*//获取到一条流水线，并把集合中的数据放到流水线上
        Stream<String> stream1 = list.stream();
        //使用终结方法打印一下流水线上的所有数据
        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                //s:依次表示流水线上的每一个数据
                System.out.println(s);
            }
        });*/
        list.stream().forEach(s -> System.out.println(s));


    }
}

双列集合获取Stream流

双列集合（如Map）需先转换为单列集合（如entrySet、keySet、values），再获取流。

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);

// 获取键的流
Stream<String> keyStream = map.keySet().stream();
// 获取值的流
Stream<Integer> valueStream = map.values().stream();
// 获取键值对的流
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

实例：

public class StreamDemo3 {
    public static void main(String[] args) {
        //双列集合      无                                                   无法直接使用stream流


        //1.创建双列集合
        HashMap<String,Integer> hm = new HashMap<>();
        //2.添加数据
        hm.put("aaa",111);
        hm.put("bbb",222);
        hm.put("ccc",333);
        hm.put("ddd",444);

        //3.第一种获取stream流
        //hm.keySet().stream().forEach(s -> System.out.println(s));

        //4.第二种获取stream流
        hm.entrySet().stream().forEach(s-> System.out.println(s));
    }
}

数组获取Stream流

通过Arrays.stream()方法或Stream.of()方法获取流。

String[] array = {"Apple", "Banana", "Orange"};

// 方式1
Stream<String> stream1 = Arrays.stream(array);
// 方式2
Stream<String> stream2 = Stream.of(array);

实例：

public class StreamDemo4 {
    public static void main(String[] args) {
        // 数组          public static <T> Stream<T> stream(T[] array)        Arrays工具类中的静态方法

        //1.创建数组
        int[] arr1 = {1,2,3,4,5,6,7,8,9,10};

        String[] arr2 = {"a","b","c"};


        //2.获取stream流
        // Arrays.stream(arr1).forEach(s-> System.out.println(s));

        //System.out.println("============================");

        //Arrays.stream(arr2).forEach(s-> System.out.println(s));


        //System.out.println("============================");


        //注意：
        //Stream接口中静态方法of的细节
        //方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组
        //但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当做一个元素，放到Stream当中。
        Stream.of(arr1).forEach(s-> System.out.println(s));//[I@41629346




    }
}

零散数据获取Stream流

使用Stream.of()直接生成流。

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

实例：

public class StreamDemo5 {
    public static void main(String[] args) {
        //一堆零散数据   public static<T> Stream<T> of(T... values)           Stream接口中的静态方法

        Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
        Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));





    }
}

其他方式

生成无限流：通过Stream.iterate()或Stream.generate()。

// 从0开始，每次加2
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);
// 生成随机数流
Stream<Double> randomStream = Stream.generate(Math::random);

文件流：通过Files.lines()读取文件内容为流。

Path path = Paths.get("file.txt");
Stream<String> fileStream = Files.lines(path);

基本类型流：如IntStream、LongStream、DoubleStream。
```
IntStream intStream = IntStream.of(1, 2, 3);
```

示例整合

以下代码展示不同数据源如何获取Stream流并操作：

import java.util.*;
import java.util.stream.*;
import java.nio.file.*;

public class StreamExample {
    public static void main(String[] args) {
        // 单列集合
        List<String> list = Arrays.asList("Java", "Python", "C++");
        list.stream().filter(s -> s.startsWith("J")).forEach(System.out::println);

        // 双列集合
        Map<String, Integer> map = Map.of("A", 1, "B", 2);
        map.entrySet().stream()
           .filter(e -> e.getValue() > 1)
           .forEach(e -> System.out.println(e.getKey()));

        // 数组
        String[] array = {"Apple", "Banana"};
        Arrays.stream(array).map(String::toUpperCase).forEach(System.out::println);

        // 零散数据
        Stream.of(1, 2, 3).map(n -> n * 2).forEach(System.out::println);
    }
}

Stream流的核心优势在于链式操作和惰性执行，能够高效处理大量数据且代码可读性强。