Java高级特性1_流库_初体验

时间：2023-03-08 22:53:05
Java高级特性1_流库_初体验

Java高级特性流库_初体验

面对结果编程

在编程里, 有两种编程方式, 一种是面对过程编程, 一种是面对结果编程. 两者区别如下

面向过程编程

Java高级特性1_流库_初体验

面向过程编程需要编程程序让程序依次执行得到自己想要的结构

面向结果编程

Java高级特性1_流库_初体验

流库带给我们的好处就是我们不需要知道过程, 只需要提供我们的需要, 具体怎么做由流库内部实现

1. 迭代到流代码演示

流库正如其名所示, 它处理的是大量元素.

这里可以将流库比作一个水管, 流库中的许多函数比作水龙头, 函数成立, 水龙头便打开让水流动, 函数不成立, 水龙头关闭, 锁住水.

public class FlowDemo2 {

    public static void main(String[] args) throws IOException {

        int count = 0;

//        读取文本文件, 其中是一段文章

        String s = new String(Files.readAllBytes(Paths.get("src","a.txt")));

        String[] split = s.split("\\n");

//        面向过程编程 统计段落长度大于90的数量

        for (String s1 : split){

            if(s1.length() > 90) count++;

        }

//        面向结果编程 统计段落长度大于90的数量

        List<String> list = Arrays.asList(split);

        System.out.println(list.stream().filter(w -> w.length() > 90).count());

//        另一种数组转流的方式

//        Stream<String> stream = Arrays.stream(split);

//        System.out.println(stream);

//        System.out.println(stream.filter(w -> w.length() > 90)

//                .count());

//        System.out.println(count);

    }

}

结果一致, 都为6.

2. 流的优点

  1. 更加简洁明了
  2. 能够链式操作( 每次返回的数据类型都是流 )
  3. 流不会存储元素, 节约内存
  4. 流的操作不会修改数据源
  5. 我的理解: 流是单向的, 只会单方向流动改变, 不会改变之前的状态, 流动过了就过了, 不会再回来

3. 创建流的方式

根据流的长度可以分为无限流和有限长度的流

Java中有大量API可以产生流, 假如有方法可以返回大量数据, 那么就可以查查文档看, 是否有转换为流的方法.

Stream接口生成有限长度的流的方式

//        第一种

//        Stream.of(可变长参数数组)

        int[] arr1 = {2, 34, 6, 8, 9, 19};

        int[] arr2 = {2, 4, 5};

        Stream<int[]> stream1 = Stream.of(arr1, arr2);

        System.out.println(stream1.getClass());

//        第二种

        int[] arr3 = {2, 34, 6, 8, 9, 19};

//        截取数组部分, 从1到2, 不包括结束

        IntStream stream = Arrays.stream(arr3, 1, 3);

        System.out.println(stream.sum());

//		  创建空流

		Stream.empty()

Stream接口生成无限流的方法

//        第三种, 创建无限流之generate

        Stream<Integer> generate = Stream.generate(() -> 1);

        generate.filter(w -> {

            System.out.println(w);

            return w>0;

        });

//        Stream.generate(参数为一个函数, 返回值必须是一个数,

//        该方法被不停调用并将返回值赋予流成为水流中的一员)

        Stream<Double> generate1 = Stream.generate(Math::random);

//        必须有count, 否则在filter中的sout失效

        generate1.filter((w) -> {

            System.out.println(w);

            return w>0.5;

        }).count();

//        创建无限流之iterate

//		  Stream.iterate(种子参数, 迭代函数), 种子参数表示迭代时的初始值, 迭代函数表示每次

//		  执行函数修改上一次迭代函数返回的值, 再作为本次函数的返回值返回,用下面的例子

//		  种子为0, 每次基于上次的结果值加1, 流中存储的数据为0, 1, 2, 3, 4 ...

//        问题: 每次停止运行后,再次运行的迭代函数是基于上次结束的返回值, 难道是有缓存,

// 		  	停止时打印6002, 再次运行时从6003开始

        Stream<Integer> iterate = Stream.iterate(0, n -> n += 1);

        iterate.filter((w) -> {

            System.out.println(w);

            return w>0.5;

        }).count();

        iterate.forEach(w -> System.out.println(w));

热烈欢迎大家看下, 一起解决上述程序最后提出的问题

总结

对流的操作加上 Lambda 表达式能够使程序更加简洁易懂, 也正是由于简洁, 不易将这种类型的程序内容书写太多, 否则过了一段时间, 自己都看不懂这段代码.

在后续对大量元素的处理, 可以优先考虑流, 而非集合

相关文章