Jdk8中Stream流的使用,让你脱离for循环

学习要求:知道一点儿函数式接口和Lambda表达式的基础知识,有利于更好的学习。

1.先体验一下Stream的好处

需求:给你一个ArrayList用来保存学生的成绩,让你打印出其中大于60的成绩。

  1. public static void main(String[] args) {

  2. ArrayList<Integer> arrList = new ArrayList<>();

  3. for (int i = 0; i < 100; i++) {

  4. arrList.add((int) (Math.random() * 100));

  5. }

  6. printValue1(arrList);

  7. }

  • 解决方案一:当然就是遍历这个ArrayList,然后使用if判断一下,如果其大于60,就将其输出,代码如下:
  1. private static void printValue1(ArrayList<Integer> arrList) {

  2. for (Integer i : arrList) {

  3. if (i > 60) {

  4. System.out.printf("%d ",i);

  5. }

  6. }

  7. }

  • 解决方案二:使用Stream流操作,只需要一行代码
  1. /**

  2. * 使用Stream操作

  3. *

  4. * @param arrList

  5. */

  6. private static void printValue2(ArrayList<Integer> arrList) {

  7. arrList.stream().filter(i -> i > 60).forEach(System.out::println);

  8. }

2.什么是Stream流?

在Jdk1.8中引入了stream流的概念,这个“流”并不同于IO中的输入和输出流,它是Jdk中的一个类,具体位置在:java.util.stream.Stream 关于它的操作主要分为三种:获取流、中间操作、最终操作

2.1 如何获取流?

所谓获取流,就是将其他对象(非Stream对象)转为Stream对象。只有两类对象可能转化为Stream对象,分别是:

  • 数组(这个数组中的元素必须是引用类型)
  1. Integer[] iArr = {12, 14, 15, 15, 17, 19, 22};

  2. Stream<Integer> stream1 = Stream.of(iArr);

  • 集合
  1. List<T> list = new ArrayList<T>();

  2. Stream<T> stream = list.stream();

2.2 中间操作(返回的是一个新的Stream对象)

从上边获取这个流对象时,我们就可以这个Stream对象进行操作,在执行结束操作前,可以无限次的执行这个操作。在开发工具中可以看到这个类的源码,它的主要有以下几种操作:

细心的话,你会发现,这个类的大多数方法中的参数全都是一个函数式接口(具体可以看上一篇文章),所以这就是为什么可以使用Lambda表达式的原因

  • map 将一种类型的值转换成另外一种类型,并返回一个新的Stream
  1. // 将集合中的字符串装换成大写形式

  2. Stream<String> stream0 = Stream.of("a", "b", "hello")

  3. .map(new Function<String, String>() {

  4. @Override

  5. public String apply(String s) {

  6. return s.toUpperCase();

  7. }

  8. });

`//上边的代码可以使用Lambda表达式简写为如下格式`


 
  1. Stream <String> stream = Stream.of("a", "b", "hello")

  2. .map(s -> s.toUpperCase());

所以,请一定要懂得Lambda表达式的操作

  • filter 遍历数据并检查、过滤其中的元素
  1. Stream<String> stream1 = Stream.of("a", "abc", "abcdefg")

  2. .filter(value -> value.length() > 1);

  • flatMap 可用Stream替换值,然后将多个Stream连接成一个Stream,会将之前生成Stream流的每一个元素更换为一个新的Stream对象。
  1. Stream <Integer> stream2 = Stream.of(1, 2)

  2. .flatMap(numbers -> Stream.of(5, 6, 6, 7, 8));

上边代码会生成的Stream中,会将1,2替换为5,6,7,8,5,6,7,8

  • 其他的常见操作还有:
  1. stream.limit(5) //限制,只取前几个元素

  2. .skip(1) //跳过,表示跳过前几个元素

  3. .distinct() //去重

  4. .sorted() //自然排序

  5. .sorted(Integer::compareTo)//自定义排序

2.3 最终操作

最终操作就是达到我们想要的结果,包括打印、转为其他对象(主要是集合,还有函数式接口的子类对象)等。只能执行一次,执行完闭后,不能再执行其他操作。

  • reduce 一般用于计算累加的,如下代码
  1. // 获取累加的值,reduce第一个参数是初始值

  2. Integer count = Stream.of(1, 2, 3)

  3. .reduce(0, (o1, o2) -> o1 + o2);

  4. System.out.println(count);//6

  • collect 将流转换为其他形式。参数是传入Collectors的一些静态方法,比如以下:
  1. Set<Integer> collect = stream.collect(Collectors.toSet());

  2. List<Integer> collect2 = stream.collect(Collectors.toList());

  3. HashSet<Integer> collect1 = stream.collect(Collectors.toCollection(HashSet::new));

  4. List<Integer> list = Stream.of(1, 2)

  5. .collect(Collectors.toList());

  • forEach 遍历这个流对象中的元素
  1. Stream.of(1, 2).forEach(i -> System.out.print(i));

  2. System.out.println();

`  
//上边格式可以使用静态方法引用的方法简化`


 
  1. Stream .of(1, 2).forEach(System.out::print);

最后,写一个简单的例子,比较一下,我们使用之前的遍历操作和使用Stream流操作的简洁性与性能问题

相比之下 ,Stream流的操作要比使用迭代器操作慢一点儿,但是这是很小的差别

本文分享自微信公众号 - 小鱼与Java(Fish_Java)。
如有侵权,请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。

评论

暂无评论