栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java8 Stream流

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java8 Stream流

java8 stream流

理论:
stream是用于对集合迭代器的增强,能够完成高效聚合操作(过滤,排序,统计分组)或大批量数据操作
流的操作特性
1,stream不存储数据
2,stream 不改变数据源
3,stream不可重复使用
流的操作类型
中间操作:
调用中间操作方法会返回一个新的流,通过连续执行多个操作就组成了Stream中的执行管道,需要注意的是这些管道被添加后并不会真正执行,只有等到终止操作后才会执行。
无状态:处理的元素不受之前元素的影响
unordered()
filter() 返回结果生成新的流中只包含满足筛选条件的数据
map() 接收一个函数作为参数,将流中的每个元素通过此函数映射为新的元素,病作为新流中对应的元素

Stream stream = Stream.of(1, 2, 3);
stream.map(a->a * a).forEach(System.out::print); // 149

mapToInt()
mapToLong()
mapToDouble()
flatMap() 将流中的每个元素都放到一个流中,最后将所有流合并成一个新流,所有流对象的元素都合并到新生成的流中返回

List num1 = Arrays.asList(1, 2, 3);
List num2 = Arrays.asList(4, 5, 6);
List num3 = Arrays.asList(7, 8, 9);
List> lists = Arrays.asList(num1, num2, num3);
Stream outputStream = lists.stream().flatMap(l -> l.stream());
List flatMapResult = outputStream.sorted().collect(Collectors.toList());
System.out.println(flatMapResult);
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

flatMapToInt()
flatMapToLong()
flatMapToDouble()
peek() 对流中每个元素执行操作,并返回一个新的流,返回的流还是原来流中的元素,与map类似

有状态:该操作只有拿到所有元素之后才能继续下去
distinct() 数据去重
sorted() 自然排序,流中的元素实现Comparable接口,默认从小到大排序
sorted(Comparator com) 定制排序,自定义Comparator排序器

List list = Arrays.asList("aa", "ff", "dd");
//String 类自身已实现Compareable接口
list.stream().sorted().forEach(System.out::println);// aa dd ff
 
Student s1 = new Student("aa", 10);
Student s2 = new Student("bb", 20);
Student s3 = new Student("aa", 30);
Student s4 = new Student("dd", 40);
List studentList = Arrays.asList(s1, s2, s3, s4);
 
//自定义排序:先按姓名升序,姓名相同则按年龄升序
studentList.stream().sorted(
        (o1, o2) -> {
            if (o1.getName().equals(o2.getName())) {
                return o1.getAge() - o2.getAge();
            } else {
                return o1.getName().compareTo(o2.getName());
            }
        }
).forEach(System.out::println);

limit(n) 返回指定数量的元素流,返回的是stream里面前面的n个元素
skip(n) 将前几个元素跳过(取出)再返回一个流,如果流中的元素小于或者等于n,就会返回一个空的流

终止操作:
在调用该方法后,将执行之前的所有中间操作,获取返回结果,病结束对流的使用
非短路操作:指必须处理所有元素才能得到最终结果
forEach() 内部迭代,串行按照顺序
forEachOrdered() 在并行中:forEachOrdered() 严格按照原来顺序取数,foreach是随机排列

toArray() 流转数组
reduce() 可以将流中元素反复结合起来,得到一个值

List list = Arrays.asList(1,2,3,4);
// reduce()方法中第一个参数是起始值,第二个参数Lambda表达式中第一个参数x就是起始值,lambda表达式第二个参数y就是集合中的每个值
// 遍历集合中每个参数作为y,然后进行计算(x+y) 得到结果作为x,最后将所有结果相加,得到sum
Integer sum = list.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum); // 10


Integer sum = list.stream().reduce((x, y) -> x + y).get();
System.out.println(sum); // 10

collect() 将流转为其他形式,接收一个Collector接口的实现,用户给strem中元素做汇总的方法
max() 返回流中最大值
min() 但会流中最小值
count() 返回流中总数
短路操作:指遇到某些符合条件的元素就可以得到最终结果,如A||B,只要A为true,则无需判断B的结果
anyMatch()
allMatch() 检查是和否匹配所有元素
noneMatch() 检查是否没有匹配所有元素
findFirst() 返回第一个元素
findAny() 返回当前流中的任意元素
Collectors.toCollection() 自定义转换类型 允许对集合再做一次操作

List custListResult = list.stream().collect(Collectors.toCollection(LinkedList::new));
System.out.println(custListResult.getClass()); // class java.util.LinkedList

Collectors.collectingAndThen()

List collectAndThenResult = list.stream()                .collect(Collectors.collectingAndThen(Collectors.toList(), l -> {return new ArrayList<>(l);}));
System.out.println(collectAndThenResult);	// [A, B, C, D]

Collectors.joining() :joining用来连接stream中的元素

String joinResult = list.stream().collect(Collectors.joining());
System.out.println(joinResult);	// ABCD
String joinResult1 = list.stream().collect(Collectors.joining(" "));
System.out.println(joinResult1);// A B C D
String joinResult2 = list.stream().collect(Collectors.joining(" ", "E","F"));
System.out.println(joinResult2);// EA B C D

Collectors.counting() counting主要用来统计stream中元素个数
Collectors.summarizingDouble/Long/Int() summarzingDouble/Long/Int为stream中的元素生成了统计信息,返回的结果是一个统计类

IntSummaryStatistics intResult = list.stream()
                .collect(Collectors.summarizingInt(String::length));
System.out.println(intResult);	// IntSummaryStatistics{count=4, sum=4, min=1, average=1.000000, max=1}

Collectors.averagingDouble/Long/Int()
averagingDouble/Long/Int()对stream中的元素做平均

Collectors.summingDouble/Long/Int()
summingDouble/Long/Int() 对stream中的元素做sum操作

Collectors.maxBy()/minBy()
maxBy() /minBy()根据提供的Comparator,返回stream中的最大或者最小值

Optional maxByResult = list.stream().collect(Collectors.maxBy(Comparator.naturalOrder()));
System.out.println(maxByResult);	// Optional[D]

Collectors.groupingBy()
GroupingBy根据某些属性进行分组,并返回一个Map

Map> groupByResult = list.stream()
                .collect(Collectors.groupingBy(String::length, Collectors.toSet()));
System.out.println(groupByResult);	// {1=[A, B, C, D]}

Collectors.partitioningBy()
PartitioningBy是一个特别的groupingBy,PartitioningBy返回一个Map,这个Map是以boolean值为key,从而将stream分成两部分,一部分是匹配PartitioningBy条件的,一部分是不满足条件的

Map> partitionResult = list.stream()
                .collect(Collectors.partitioningBy(s -> s.length() > 3));
System.out.println(partitionResult); // {false=[A, B, C, D], true=[]}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/972938.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号