2、Stream API
2016-06-22 00:00
330 查看
2.1 概述
Steam API 是 Java 8 中全新的特性,它基于Lambda 表达式,对集合(Collection)的各种操作进行了大幅度的增强,极大的提高了编码的效率和程序的可读性。Stream API 提供串行和并行两种模式,并行模式会自动创建多个线程,使用 fork/join(Java 7 特性) 并行方式来拆分任务和加速处理过程,能充分利用多核处理器。牛X的是,我们并不需要手动写多线程处理的代码,Stream API 自行实现了高性能的并发程序。
eg,看一下下面这段代码干了什么?然后想一下如果不使用 Stream 操作,应该怎么实现?
Set<String> zoneIds = ZoneId.getAvailableZoneIds(); zoneIds.stream().filter(zoneId -> zoneId.startsWith("Asia")).skip(10).limit(5).forEach(System.out::println);
2.1.1 什么是 Stream
这里的 Stream 跟 IO流等其它流并不是指同样的东西,而是对集合执行流式操作的一种抽象。要分清一点,Stream 不是数据结构,本身不存储元素,元素可能存储在底层的集合中,或根据需要产生出来。2.1.2 如何使用
Stream API 的用法很简单,分3步执行,即:创建/获取流 -> 中间操作(过滤、转换等) -> 终止操作( 聚合、收集结果)
其中,
中间操作可以执行多次,并且都是延迟执行的,每次操作原有的 Stream 对象不改变,会产生一个新的 Stream;
终止操作只能有一个,一旦执行完成,Stream 就没了。
2.2 创建流
2.2.1 从集合创建
Java 8 中,Collection 接口增加了 stream 方法,所以我们可以把任何一个集合转成StreamSet<String> zoneIds = ZoneId.getAvailableZoneIds(); Stream<String> demo = zoneIds.stream();
2.2.2 从数组创建
Arrays 类中增加了 stream(T[] array)方法String[] arr = {"1"}; Stream<String> demo = Arrays.stream(arr);
2.2.3 从静态方法创建
Stream.of(T... values)Stream.generate(Supplier<T> s) 生成无限流
Stream.iterate(final T seed, final UnaryOperator<T> f), 生成无限流,但是多了一个seed,生成的流是 seed, f(seed), f(f(seed))...
Stream.of("1", "2", "2", "5", "7", "5", "6", "3", "4", "3"); Stream<Integer> stream1 = Stream.generate(() -> RandomUtils.nextInt(1, 10)); stream1.limit(10).forEach(System.out::print); // 输出 2223915594 Stream<Integer> stream2 = Stream.iterate(1, x -> x + 1); stream2.limit(10).forEach(System.out::print); // 12345678910
2.2.4 其它
java.io.BufferedReader.lines()java.util.stream.IntStream.range()
java.nio.file.Files.walk()
java.util.Spliterator
Random.ints()
BitSet.stream()
Pattern.splitAsStream(java.lang.CharSequence)
JarFile.stream()
2.3 中间操作
2.3.1 过滤
filter流中所有符合条件的数据转到新流。filter方法的参数是一个 Pridicate<? super T> 类型的函数式接口,即一个返回 boolean 类型的 Lambda表达式。
Set<String> zoneIds = ZoneId.getAvailableZoneIds(); Stream<String> oldStream = zoneIds.stream(); Stream<String> newStream = oldStream.filter(zoneId -> zoneId.startsWith("Asia"));
2.3.2 转换
map流中所有数据,经过处理后转到新流。map方法的参数是一个 Function<? super T, ? extends R> 类型的函数式借口,即接收一个参数并返回处理后的结果。
另,flatMap 方法会展开转换的元素。
Set<String> zoneIds = ZoneId.getAvailableZoneIds(); Stream<String> oldStream = zoneIds.stream(); Stream<String> newStream = oldStream.map(zoneId -> zoneId.replace("//", "-"));
2.3.3 提取
获取一个流的一部分。Set<String> zoneIds = ZoneId.getAvailableZoneIds(); zoneIds.stream().skip(10).limit(5); // 另一个较好的例子 Stream<Integer> limit = Stream.generate(() -> RandomUtils.nextInt(1, 10)).limit(100);
2.3.4 组合
将两个流合并成一个Stream.concat(Stream.of("1", "2"), Stream.of("4", "5", "6"));
2.3.5 其他
distinct 去重sorted 排序
peek 监听。可以指定一个函数,当元素被处理的时候被每个元素调用
parallel 转为并行流
sequential 转为串行流
unordered 不知道
Stream.of("1", "2", "2", "5", "7", "5", "6", "3", "4", "3") .peek(x -> System.out.println(x+" ")) .filter(x -> x.compareTo("3")>0) .map(x -> x.replace("5", "9")) .distinct() .sorted() .skip(1) .limit(5) .forEach(System.out::print);
最终结果:
1 2 2 5 7 5 6 3 4 3 679
2.3.6 小结
思考一个疑问,我们对一个 Stream 进行多次转换操作,每次都会产生一个新的 Stream,这样操作是不是比我们自己写单次循环耗费更多的时间?不是,转换操作都是lazy的,多个转换操作只会在终止操作的时候融合起来,一次循环完成。
2.4 终止操作
这部分是 Stream API 中最重要的内容,从上文中我们已经知道如何创建一个流以及如何对其进行转换。现在,我们要从流中获取结果。2.4.1 聚合操作
reduce这是一个通用的聚合方法,最基本的 reduce 方法接收一个 BinaryOperator<T> 类型的参数,使用的方式是这个样子的:
IntStream is = IntStream.of(1, 2, 3 , 4, 5); System.out.println(is.reduce((a, b) -> a+b)); // 输出 OptionalInt[15]
在这个操作里可以看到,reduce 方法有两个参数。其中第1个参数是上次操作返回的结果,第2个参数是 Stream 中下一个元素。如果是第一次执行,第1个参数是 Stream 中的第一个元素, 第2个参数是Stream 中的第2个元素。简单描述一下这个操作的执行过程,
操作 | 结果 |
---|---|
首先流初始化后有5个元素 | 1, 2, 3, 4, 5 |
第1次聚合 | 3,3, 4, 5 |
第2次聚合 | 6, 4, 5 |
第3次聚合 | 10, 5 |
第4次聚合 | 15 |
IntStream is = IntStream.of(); System.out.println(is.reduce(5, (a, b) -> a+b)); // 输出 5
2.4.2 聚合方法
很多情况下,我们所做的聚合操作都是一样的。所以为了方便,Stream API 直接提供了常用的聚合方法sum
IntStream s = IntStream.of(1,2,3,4); System.out.println(s.sum());
注:只有 IntStream、LongStream、DoubleStream 才有 sum 方法
count、max、min
System.out.println(ZoneId.getAvailableZoneIds().stream().count()); // 输出 590 System.out.println(ZoneId.getAvailableZoneIds().stream().min(String::compareTo)); // 输出 Optional[Africa/Abidjan] System.out.println(ZoneId.getAvailableZoneIds().stream().max(String::compareTo)); // 输出 Optional[Zulu]
findFirst、findAny
System.out.println(ZoneId.getAvailableZoneIds().stream().findFirst()); // Optional[Asia/Aden] System.out.println(ZoneId.getAvailableZoneIds().stream().findAny()); // Optional[Asia/Aden]
anyMatch、 allMatch、 noneMatch
allMatch:Stream 中全部元素符合传入的 predicate,返回 true
anyMatch:Stream 中只要有一个元素符合传入的 predicate,返回 true
noneMatch:Stream 中没有一个元素符合传入的 predicate,返回 true
System.out.println(ZoneId.getAvailableZoneIds().stream().allMatch(x -> x.startsWith("A"))); // false System.out.println(ZoneId.getAvailableZoneIds().stream().anyMatch(x -> x.startsWith("A"))); // true System.out.println(ZoneId.getAvailableZoneIds().stream().noneMatch(x -> x.startsWith("A"))); // false
2.4.3 收集结果
collect把结果收集到容器中,collect 方法的基本方法是这个
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
但是这个方法用着比较麻烦, 一般直接用另外的工具方法
收集到集合
List<String> list = ZoneId.getAvailableZoneIds().stream().limit(5).collect(Collectors.toList()); Set<String> set = ZoneId.getAvailableZoneIds().stream().collect(Collectors.toSet());
收集到Map
Map<String, String> map = ZoneId.getAvailableZoneIds().stream() .limit(3) .collect(Collectors.toMap(x -> x, y -> y)); System.out.println(map); // 输出 {Asia/Aden=Asia/Aden, America/Cuiaba=America/Cuiaba, Etc/GMT+9=Etc/GMT+9}
2.4.5 遍历结果
并不是所有时候我们都需要把结果汇聚在一起,我们也可以只是遍历各个元素iterator
转成传统的迭代器
Stream<String> zoneIdStream = ZoneId.getAvailableZoneIds().stream(); Iterator<String> it = zoneIdStream.iterator();
forEach、 forEachOrdered
ZoneId.getAvailableZoneIds().stream().limit(5).forEach(System.out::print);
2.4.6 分组
groupingBy基本的分组方法描述是这样的,第一个参数是分组函数,第二个参数是返回的类型,第三个参数是一个收集器
public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
最简单的用法是只提供一个分组函数,那么默认会返回
Map<String, List<String>> map = ZoneId.getAvailableZoneIds().stream() .limit(5) .collect(Collectors.groupingBy(x -> x.substring(0, x.indexOf("/"))) ); System.out.println(map); // 输出 {Etc=[Etc/GMT+9, Etc/GMT+8], Asia=[Asia/Aden], Africa=[Africa/Nairobi], America=[America/Cuiaba]}
如果我们想控制类型,可以用Collectors改变,比如
Map<String, Set<String>> map = ZoneId.getAvailableZoneIds().stream() .limit(5) .collect(Collectors.groupingBy(x -> x.substring(0, x.indexOf("/")), Collectors.toSet()) );
Stream Api 还提供其他一些收集器,比如counting,计算每个分组的元素数量
Map<String, Long> map = ZoneId.getAvailableZoneIds().stream() .limit(5) .collect(Collectors.groupingBy(x -> x.substring(0, x.indexOf("/")), Collectors.counting())); System.out.println(map); // 输出 {Etc=2, Asia=1, Africa=1, America=1}
2.4.7 Optional 类型
在前文的介绍中,你应该看到了 Optional 这个东西,有很多终止操作的结果是Optional<T>。那么,Optional是什么?Optional 是一个容器,它可能包含也可能不包含一个值,用意是替代不安全的返回类型 NULL。比如,我们常见的一种代码,
public Integer getInteger() { return null; }
如果我们需要使用这个方法,一般是这样的
Integer i = getSomething(); if(i != null) { System.out.println(i); // do something }
调用一个返回T类型的方法后,为了安全我们必须验证这个对象不是 NULL,造成代码的阅读星和维护性都比较差,但是如果没有这样做,就很可能出现 NullPointException。
Optional 就是为了解决这个问题而设计的,它提供了一个接受 Consumer<? super T>类型参数的方法 ifPresent,只有当存在可用的元素时,才执行逻辑
public Optional<Integer> getSomethingOptinal() { return Optional.empty(); }
我们直接调用这个方法
getSomethingOptinal().ifPresent(System.out::print);
正常执行,没有异常。
所以现在当我们一个方法返回List集合时,应该总是返回一个空的List,而不是Null; 当一个返回T类型的方法有可能为Null 时,应该该用Optional<T>。
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- c++11 + SDL2 + ffmpeg +OpenAL + java = Android播放器
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树