Java8 Stream API

Stream API是Java8中处理集合的关键组件,提供了各种丰富的函数式操作。

Stream的创建

任何集合都可以转换为Stream:

//数组

String[] strArr =newString[]{"aa","bb","cc"};
Stream streamArr = Stream.of(strArr);
Stream streamArr2 = Arrays.stream(strArr);

//集合

List list =newArrayList<>();
Stream streamList = list.stream();
Stream streamList2 = list.parallelStream();

//并行执行...//generator 生成无限长度的

streamStream.generate(Math::random);

// iterate 也是生成无限长度的Stream,其元素的生成是重复对给定的种子值调用函数来生成的Stream.iterate(1, item -> item +1)

Stream的简单使用

Stream的使用分为两种类型:

Intermediate,一个Stream可以调用0到多个Intermediate类型操作,每次调用会对Stream做一定的处理,返回一个新的Stream,这类操作都是惰性化的(lazy),就是说,并没有真正开始流的遍历。

常用操作:map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel

Terminal,一个Stream只能执行一次terminal 操作,而且只能是最后一个操作,执行terminal操作之后,Stream就被消费掉了,并且产生一个结果。

常用操作:forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny

使用示例:

//filter 过滤操作
streamArr.filter(str->str.startsWith("a"));
//map 遍历和转换操作
streamArr.map(String::toLowerCase);
//flatMap 将流展开
Listlist1=newArrayList<>();
list1.add("aa");list1.add("bb");
Listlist2=newArrayList<>();
list2.add("cc");
list2.add("dd");
Stream.of(list1,list2).flatMap(str->str.stream()).collect(Collectors.toList());
//limit 提取子流
streamArr.limit(1);
//skip 跳过
streamArr.skip(1);
//peek 产生相同的流,支持每个元素调用一个函数
streamArr.peek(str->System.out.println("item:"+str));
//distinct 去重
Stream.of("aa","bb","aa").distinct();
//sorted 排序Stream.of("aaa","bb","c").sorted(Comparator.comparing(String::length).reversed());
//parallel 转为并行流,谨慎使用
streamArr.parallel();
//forEach
streamArr.forEach(System.out::println);
//forEachOrdered 如果希望顺序执行并行流,请使用该方法streamArr.parallel().forEachOrdered(System.out::println);
//toArray 收集到数组中
streamArr.filter(str->str.startsWith("a")).toArray(String[]::new);
//reduce 聚合操作
streamArr.reduce((str1,str2) -> str1+str2);
//collect收集到List中
streamArr.collect(Collectors.toList());
//collect收集到Set中
streamArr.collect(Collectors.toSet());
//min取最小值
IntStream.of(1,2,3,4).min();
Stream.of(arr).min(String::compareTo);
//max取最大值
IntStream.of(1,2,3,4).max();
Stream.of(arr).max(String::compareTo);
//count计算总量
streamArr.count();
//anyMatch判断流中是否含有匹配元素
boolean hasMatch = streamArr.anyMatch(str -> str.startsWith("a"));
//allMatch判断流中是否全部匹配
boolean hasMatch = streamArr.allMatch(str -> str.startsWith("a"));
//noneMatch判断流中是否全部不匹配
boolean hasMatch = streamArr.noneMatch(str -> str.startsWith("a"));
//findFirst找到第一个就返回
streamArr.filter(str -> str.startsWith("a")).findFirst();
//findAny找到任意一个就返回
streamArr.filter(str -> str.startsWith("a")).findAny();

收集结果

collect操作主要用于将stream中的元素收集到一个集合容器中,collect函数的定义如下:

R collect(Suppliersupplier,

BiConsumeraccumulator,
BiConsumercombiner);

第一个参数Supplier用于生成一个目标集合容器类型的实例;

函数BiConsumer

Set result = Stream.of("aa","bb","cc","aa").collect(
       () -> newHashSet(),
       (set, item)->set.add(item),
       (set, subSet)->set.addAll(subSet));

以上写法可以使用操作符“::”简化,语法如下:

对象::实例方法

类::静态方法

类::实例方法

Set result=Stream.of("aa","bb","cc","aa").collect( 
            HashSet::new,    
            HashSet::add,  
            HashSet::addAll);

Java.util.stream.Collectors类中已经预定义好了toList,toSet,toMap,toCollection等方便使用的方法,所以以上代码还可以简化如下:

Set result2 = Stream.of("aa","bb","cc","aa").collect(Collectors.toSet());

将结果收集到Map中,Collectors.toMap方法的两个重载定义如下:

keyMapper函数用于从实例T中得到一个K类型的Map key;

valueMapper函数用于从实例T中得到一个U类型的Map value;

mergeFunction函数用于处理key冲突的情况,默认为throwingMerger(),抛出IllegalStateException异常;

mapSupplier函数用于生成一个Map实例;

publicstatic    Collector> toMap(Function keyMapper,         
       Function valueMapper) {returntoMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);    }
publicstatic>    Collector toMap(Function keyMapper,                         
       Function valueMapper,                           
     BinaryOperator mergeFunction,                            
    Supplier mapSupplier) {    
    BiConsumer accumulator                = (map, element) -> map.merge(keyMapper.apply(element),                                              valueMapper.apply(element), mergeFunction);
returnnewCollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);  
  }

假设有一个User实体类,有方法getId(),getName(),getAge()等方法,现在想要将User类型的流收集到一个Map中,示例如下:

Stream userStream=Stream.of(newUser(0,"张三",18),newUser(1,"张四",19),newUser(2,"张五",19),newUser(3,"老张",50));
Map userMap=userSteam.collect(Collectors.toMap(User::getId, item->item));

假设要得到按年龄分组的Map>,可以按这样写:

Map>ageMap=userStream.collect(Collectors.toMap(User::getAge, Collections::singletonList, (a, b)->{ListresultList=newArrayList<>(a);            resultList.addAll(b);returnresultList;        }));

这种写法虽然可以实现分组功能,但是太过繁琐,好在Collectors中提供了groupingBy方法,可以用来实现该功能,简化后写法如下:

Map>ageMap2=userStream.collect(Collectors.groupingBy(User::getAge));

类似的,Collectors中还提供了partitioningBy方法,接受一个Predicate函数,该函数返回boolean值,用于将内容分为两组。假设User实体中包含性别信息getSex(),可以按如下写法将userStream按性别分组:

Map> sexMap = userStream.collect(Collectors.partitioningBy(item -> item.getSex() >0));

Collectors中还提供了一些对分组后的元素进行downStream处理的方法:

counting方法返回所收集元素的总数;

summing方法会对元素求和;

maxBy和minBy会接受一个比较器,求最大值,最小值;

mapping函数会应用到downstream结果上,并需要和其他函数配合使用;

MapsexCount=userStream.collect(Collectors.groupingBy(User::getSex,Collectors.counting()));MapageCount=userStream.collect(Collectors.groupingBy(User::getSex,Collectors.summingInt(User::getAge)));Map>ageMax=userStream.collect(Collectors.groupingBy(User::getSex,Collectors.maxBy(Comparator.comparing(User::getAge))));Map>nameMap=userStream.collect(Collectors.groupingBy(User::getSex,Collectors.mapping(User::getName,Collectors.toList())));

以上为各种collectors操作的使用案例。

Optional类型

Optional 是对T类型对象的封装,它不会返回null,因而使用起来更加安全。

ifPresent方法接受一个函数作为形参,如果存在当前Optinal存在值则使用当前值调用函数,否则不做任何操作,示例如下:

Optional optional =...optional.ifPresent(v -> results.add(v));

orElse方法,orElseGet方法,当值不存在时产生一个替代值,示例如下:

Stringresult =optional.orElse("defaultValue");Stringresult =optional.orElseGet(() -> getDefalutValue());

可以使用Optional.of()方法和Optional.empty()方法来创建一个Optional类型对象,示例如下:

a - b >0?Optional.of(a - b) :Optional.empty();

函数式接口

Steam.filter方法接受一个Predicate函数作为入参,该函数返回一个boolean类型,下图为Stream和COllectors方法参数的函数式接口:

总结

Stream的处理总会在最后的Terminal操作才会真正执行;

没有内部存储,也不能改变使用到的数据源,每次操作都会生成一个新的流;

并行流使用fork/join 池来实现,对于非CPU密集型任务,需要谨慎使用;

相对于循环遍历操作代码可读性更高;

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

编辑于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券