Java8中常用的新特性-Stream流

Java8中常用的新特性-Stream流 一句话

一个银行里被捉着做需求的开发人员进行自救。

---

一、我所理解的stream流

一种方便数据集合进行加工的工具，能够使代码更加简洁

• 两种生成流的方式
  • stream()为集合创建串行流
  • parallelStream()为集合创建并行流。

二、常用 *** 作 1.collect

• 终止 *** 作
• 收集起来作为输出
• collect(toList())
• collect(toSet())

2.map

• 中间 *** 作
• 将一种类型的值映射成另一种类型的值
• 可将Stream流中的每一个值映射成新值
• 用lambda表达式最香
• 例如那种数据库中返回的数据是个对象集合，可是我只需要对象中的某个属性

3.filter

• 中间 *** 作
• 过滤数据
• 如果在数据库中做过滤时间消耗过大，那么可以在代码上做，这时候这个就很好用了
• 用lambda表达式最香

4.flatMap

• 中间 *** 作
• 合并Stream
• 感觉运用场景不多怎么回事！
• 一开始我以为是可以合并两个数组，后面发现我想多了，他是合并数组中的值，例如我原本是一个二维数组，现在可以将他扁平化成一个数组。
• 行吧 后面发现基础类型int[][]数组也是不行，还是乖乖用String[]实现吧

5.reduce

• 终止 *** 作
• 用于计算较多
• max、min、count都是它的小弟，
• 如果是数据库中拿到的数据做累加，那就很香了，可以直接先filter再reduce

6.findFirst

• 终止 *** 作
• 获取第一个参数（替代get(0)）
• 通常与Optional一起用,用于get(0)时防止空指针

7.forEach

• 终止 *** 作
• 做循环 *** 作
• 通常同于打印输出

8.peek

• 中间 *** 作
• 用于Debug
• 为什么会写进来是因为考虑到forEach可以做的事情peek也可以做，那为什么不用peek呢？然后查了一下，它不应该和forEach比较，应该和map比较，实际上peek并不会改变流，因为它 *** 作后不会返回新的流回去，那么又引申出一个问题：当流里面的是对象，为什么会改到对象里面的值？答案如图
• 
  我们已经 *** 作了元素（那个对象），那么无论它返不返回，对象里面的值都会是改了的。

实践代码：

public class steamDemo {
    public static void main(String[] args) {
        String str = "my name is 007";

        Stream.of(str.split(" ")).filter(s -> s.length() > 2)
                .map(s -> s.length()).forEach(System.out::println);

        //常见 *** 作1：collect：一种终止 *** 作
        String strs[] = {"111","222","333","444"};
        List collectDemo = Stream.of(strs).collect(Collectors.toList());
        System.out.println("常见 *** 作1：collect：一种终止 *** 作");
        for(String str1 : collectDemo) System.out.println(str1);

        //常见 *** 作2：map：一种改变数据类型的方法
        List mapDemo = Stream.of(str.split(" ")).map(s -> s.toUpperCase()).collect(Collectors.toList());
        System.out.println("常见 *** 作2：map：一种改变数据类型的方法");
        for(String str1 : mapDemo) System.out.println(str1);

        //常见 *** 作3：filter：一种过滤方法
        int [] testFilterDemo = new int[]{1,2,3,4,5};
        int [] filterDemo = Arrays.stream(testFilterDemo).filter(s -> s > 2).toArray();
        System.out.println("常见 *** 作3：filter：一种过滤方法");
        for(int int1 : filterDemo) System.out.println(int1);

        //常见 *** 作4：flatMap：合并Stream流
        String[] testFlatMapDemo = new String[]{"1,2,3,4,5","6,7,8,9,10"};
        String[] flatMapDemo = Arrays.stream(testFlatMapDemo).map(s -> s.split(",")).flatMap(Arrays::stream).toArray(String[]::new);
        System.out.println("常见 *** 作4：flatMap：合并Stream流");
        for(String int1 : flatMapDemo) System.out.println(int1);

        //常见 *** 作5：reduce：使用Stream的值进行计算
        int [] reduceDemo = new int[]{1,2,3,4,5};
        int maxResult = Arrays.stream(reduceDemo).max().getAsInt();
        System.out.println("常见 *** 作5：reduce-max：找最大值");
        System.out.println(maxResult);
        int minResult = Arrays.stream(reduceDemo).min().getAsInt();
        System.out.println("常见 *** 作5：reduce-min：找最小值");
        System.out.println(minResult);
        int sumResult = Arrays.stream(reduceDemo).reduce((x,y) -> x + y).getAsInt();
        System.out.println("常见 *** 作5：reduce：累计值");
        System.out.println(sumResult);
        int sumResult2 = Arrays.stream(reduceDemo).reduce(5,(x,y) -> x + y);
        System.out.println("常见 *** 作5：reduce：累计值(可有初始值)，可能是我初始值是一个int，所以是不用加getAsInt");
        System.out.println(sumResult2);

        //常见 *** 作6：findFirst：直接获取第一个元素
        int [] findFirstDemo = new int[]{1,2,3,4,5};
        int findFirstResult = Arrays.stream(findFirstDemo).findFirst().getAsInt();
        System.out.println("常见 *** 作6：findFirst：直接获取第一个元素");
        System.out.println(findFirstResult);

        //常见 *** 作7：forEach：直接看最前一个


    }
}

总结

好好学习lambda，卷死他们~