Java中的流-yiteyi-C++库

流API是在Java8中引入的，用于处理对象集合。流是一系列支持各种方法的对象，这些方法可以通过流水线生成所需的结果。 Java stream的特点是——

null

流不是数据结构，而是从集合、数组或I/O通道获取输入。
流不会改变原始的数据结构，它们只按照流水线方法提供结果。
每个中间操作都会被延迟执行并返回一个流，因此各种中间操作都可以被流水线处理。终端操作标记流的结束并返回结果。

流上的不同操作- 中间操作：

地图： map方法用于返回一个流，该流包含将给定函数应用于该流元素的结果。 List number = Arrays.asList(2,3,4,5); List square = number.stream().map(x->x*x).collect(Collectors.toList());
过滤器： filter方法用于根据作为参数传递的谓词选择元素。 List names = Arrays.asList("Reflection","Collection","Stream"); List result = names.stream().filter(s->s.startsWith("S")).collect(Collectors.toList());
分类： 排序方法用于对流进行排序。 List names = Arrays.asList("Reflection","Collection","Stream"); List result = names.stream().sorted().collect(Collectors.toList());

航站楼运营：

收集： collect方法用于返回对流执行的中间操作的结果。 List number = Arrays.asList(2,3,4,5,3); Set square = number.stream().map(x->x*x).collect(Collectors.toSet());
forEach： forEach方法用于迭代流中的每个元素。 List number = Arrays.asList(2,3,4,5); number.stream().map(x->x*x).forEach(y->System.out.println(y));
减少： reduce方法用于将流的元素缩减为单个值。 reduce方法将二进制运算符作为参数。
List number = Arrays.asList(2,3,4,5); int even = number.stream().filter(x->x%2==0).reduce(0,(ans,i)-> ans+i);

这里ans变量被指定为0作为初始值，i被添加到其中。

演示使用流的程序

                     //a simple program to demonstrate the use of stream in java                   
                     import                               java.util.*;                   
                     import                               java.util.stream.*;                   
                             
                     class                               Demo                   
                     {                   
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                             
                                         // create a list of integers                   
                                         List<Integer> number = Arrays.asList(                               2                               ,                               3                               ,                               4                               ,                               5                               );                   
                             
                                         // demonstration of map method                   
                                         List<Integer> square = number.stream().map(x -> x*x).                   
                                         collect(Collectors.toList());                   
                                         System.out.println(square);                   
                             
                                         // create a list of String                   
                                         List<String> names =                   
                                         Arrays.asList(                               "Reflection"                               ,                               "Collection"                               ,                               "Stream"                               );                   
                             
                                         // demonstration of filter method                   
                                         List<String> result = names.stream().filter(s->s.startsWith(                               "S"                               )).                   
                                         collect(Collectors.toList());                   
                                         System.out.println(result);                   
                             
                                         // demonstration of sorted method                   
                                         List<String> show =                   
                                         names.stream().sorted().collect(Collectors.toList());                   
                                         System.out.println(show);                   
                             
                                         // create a list of integers                   
                                         List<Integer> numbers = Arrays.asList(                               2                               ,                               3                               ,                               4                               ,                               5                               ,                               2                               );                   
                             
                                         // collect method returns a set                   
                                         Set<Integer> squareSet =                   
                                         numbers.stream().map(x->x*x).collect(Collectors.toSet());                   
                                         System.out.println(squareSet);                   
                             
                                         // demonstration of forEach method                   
                                         number.stream().map(x->x*x).forEach(y->System.out.println(y));                   
                             
                                         // demonstration of reduce method                   
                                         int                               even =                   
                                         number.stream().filter(x->x%                               2                               ==                               0                               ).reduce(                               0                               ,(ans,i)-> ans+i);                   
                             
                                         System.out.println(even);                   
                                         }                   
                     }                   

输出：

[4, 9, 16, 25]
[Stream]
[Collection, Reflection, Stream]
[16, 4, 9, 25]
4
9
16
25
6

要点/观察：

流包括源，然后是组合在一起的零个或多个中间方法（流水线）和终端方法，以按照所述方法处理从源获得的对象。
流用于按照流水线方法计算元素，而不改变对象的原始值。

本文由 阿卡什奥哈 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java