Java之stream流的学习

Java之stream流的学习

欢迎移步博主小站：白亮吖雅黑丫の小站

1、学习背景

​ 你还在为处理对象数组中的元素而困恼吗?传统写法在对数组中的对象进行操作时，首先需要遍历数组(写for循环)，然后再根据需要对对象中的数据进行相应的操作，你写出来的代码或许是这样的：

class Student{
    private int age;
    private String sex;
    private String name;
    //get set函数省略
    //... ...
}

... ... //其他代码省略
 	List<Student> studenNewtList = new ArrayList<Student>();

	//1.筛选出年纪小于30的学生
    for (Student student : studentList) {
        if (student.getAge() < 30) {
            studenNewtList.add(dish);
        }
    }

    //2.对筛选出的学生进行排序
    Collections.sort(studenNewtList, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return Integer.compare(o1.getAge(), o2.getAge());
        }
    });

    //3.获取排序后菜肴的名字
    List<String> lowStudentName = new ArrayList<>();
    for (Student s : studenNewtList) {
        lowStudentName.add(s.getName());
    }
	return lowStudentName

​ 而自从在java8以后，学习stream流操作后，代码有了极大的简化，使用更加快速便捷，不需要再去写繁琐的遍历代码，几行语句即可解决所遇到的问题。简化后的代码如下：

return studentList.stream()
                .filter(s -> s.getAge() < 30)  //筛选出年纪小于30的学生
                .sorted(comparing(Student::getAge))  //根据学生年纪进行排序
                .map(Student::getName)  //提取符合条件的学生名字
                .collect(Collectors.toList()); //转换为List

​ 看过上述代码后是不是感觉自己之前写的代码有多low了！没接触stream前我也是这样的，现在了解stream后再次写代码应该趋于简洁化，以提高工作效率！

---

2、stream介绍

​ 流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算。

2.1 创建流

1. 通过集合生成，应用中最常用的一种

   List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
   Stream<Integer> stream = integerList.stream();
   

2. 通过数组生成

   int[] intArr = new int[]{1, 2, 3, 4, 5};
   IntStream stream = Arrays.stream(intArr);
   

   通过Arrays.stream方法生成流，并且该方法生成的流是数值流【即IntStream】而不是Stream。补充一点使用数值流可以避免计算过程中拆箱装箱，提高性能。

   Stream API提供了mapToInt、mapToDouble、mapToLong三种方式将对象流【即Stream】转换成对应的数值流，同时提供了boxed方法将数值流转换为对象流

3. 通过值生成

   Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
   

   通过Stream的of方法生成流，通过Stream的empty方法可以生成一个空流

4. 通过文件生成

   Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())
   

   通过Files.line方法得到一个流，并且得到的每个流是给定文件中的一行

5. 通过函数生成 提供了iterate和generate两个静态方法从函数中生成流

   • iterate

     Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(5);
     

     iterate方法接受两个参数，第一个为初始化值，第二个为进行的函数操作，因为iterator生成的流为无限流，通过limit方法对流进行了截断，只生成5个偶数

   • generate

     Stream<Double> stream = Stream.generate(Math::random).limit(5);
     

     generate方法接受一个参数，方法参数类型为Supplier，由它为流提供值。generate生成的流也是无限流，因此通过limit对流进行了截断

   ---

2.2 使用流

​ 流的使用将分为中间操作和终端操作进行介绍

2.2.1 中间操作

​ 一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。

​ 这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时，常见的中间操作有下面即将介绍的filter、map等

1. filter筛选

   filter中填筛选条件。

   List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
   Stream<Integer> stream = integerList.stream().filter(i -> i > 3);
   

2. distinct去除重复元素

   直接使用，进行去重操作

   List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
   Stream<Integer> stream = integerList.stream().distinct();
   

3. limit返回指定流个数

   通过limit方法指定返回流的个数，limit的参数值必须>=0，否则将会抛出异常

   List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
   Stream<Integer> stream = integerList.stream().limit(3);
   

4. skip跳过流中的元素

   通过skip方法跳过流中的元素，上述例子跳过前两个元素，所以打印结果为2,3,4,5，skip的参数值必须>=0，否则将会抛出异常

   List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
   Stream<Integer> stream = integerList.stream().skip(2);
   

5. map流映射

   通过map方法可以完成映射，该例子完成中String -> Integer的映射，之前上面的例子通过map方法完成了Dish->String的映射

   List<String> stringList = Arrays.asList("Java 8", "Lambdas",  "In", "Action");
   Stream<Integer> stream = stringList.stream().map(String::length);
   

6. flatMap流转换

   map(w -> w.split(" "))的返回值为Stream<String[]>，我们想获取Stream，可以通过flatMap方法完成Stream ->Stream的转换。关注微信公众号：Java技术栈，在后台回复：新特性，可以获取我整理的 N 篇最新 Java 新特性教程，都是干货。

   List<String> wordList = Arrays.asList("Hello", "World");
   List<String> strList = wordList.stream()
           .map(w -> w.split(" "))
           .flatMap(Arrays::stream)
           .distinct()
           .collect(Collectors.toList());
   

7. 元素匹配

   • allMatch匹配所有

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     if (integerList.stream().allMatch(i -> i > 3)) {
         System.out.println("值都大于3");
     }
     

   • anyMatch匹配其中一个

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     if (integerList.stream().anyMatch(i -> i > 3)) {
         System.out.println("存在大于3的值");
     }
     

   • noneMatch全部不匹配

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     if (integerList.stream().noneMatch(i -> i > 3)) {
         System.out.println("值都小于3");
     }
     

2.2.2 终端操作

​ 一个流有且只能有一个终端操作，当这个操作执行后，流就被关闭了，无法再被操作，因此一个流只能被遍历一次，若想在遍历需要通过源数据在生成流。终端操作的执行，才会真正开始流的遍历。如下面即将介绍的count、collect等

1. 统计流中元素个数

   • count

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     Long result = integerList.stream().count();
     

   • counting

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     Long result = integerList.stream().collect(counting());
     

     这一种统计元素个数的方法在与collect联合使用的时候特别有用

2. 查找

   • findFirst查找第一个

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     Optional<Integer> result = integerList.stream().filter(i -> i > 3).findFirst();
     

   • findAny随机查找一个

     List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
     Optional<Integer> result = integerList.stream().filter(i -> i > 3).findAny();
     

     通过findAny方法查找到其中一个大于三的元素并打印，因为内部进行优化的原因，当找到第一个满足大于三的元素时就结束，该方法结果和findFirst方法结果一样。

     提供findAny方法是为了更好的利用并行流，findFirst方法在并行上限制更多(不做记录 其实是不会)

3. reduce将流中的元素组合起来

   int sum = integerList.stream().reduce(0, (a, b) -> (a + b));
   
   //或者
   int sum = integerList.stream().reduce(0, Integer::sum);
   

   ​ reduce接受两个参数，一个初始值这里是0，一个BinaryOperator accumulator

   来将两个元素结合起来产生一个新值，另外reduce方法还有一个没有初始化值的重载方法。

4. 获取流中最小最大值

   • 通过min/max获取最小最大值

     Optional<Integer> min = studentList.stream().map(Student::getAge).min(Integer::compareTo);
     Optional<Integer> max = studentList.stream().map(Student::getAge).max(Integer::compareTo);
     
     //或者
     OptionalInt min = studentList.stream().mapToInt(Student::getAge).min();
     OptionalInt max = studentList.stream().mapToInt(Student::getAge).max();
     

     min获取流中最小值，max获取流中最大值，方法参数为Comparator<? super T> comparator

   • 通过minBy/maxBy获取最小最大值

     Optional<Integer> min = studentList.stream().map(Student::getAge).collect(minBy(Integer::compareTo));
     Optional<Integer> max = studentList.stream().map(Student::getAge).collect(maxBy(Integer::compareTo));
     

     minBy获取流中最小值，maxBy获取流中最大值，方法参数为Comparator<? super T> comparator

   • 通过reduce获取最小最大值

     Optional<Integer> min = studentList.stream().map(Student::getAge).reduce(Integer::min);
     Optional<Integer> max = studentList.stream().map(Student::getAge).reduce(Integer::max);
     

5. 求和

   • 通过summingInt

     int sum = studentList.stream().collect(summingInt(Student::getAge));
     

     如果数据类型为double、long，则通过summingDouble、summingLong方法进行求和

   • 通过reduce

     int sum = studentList.stream().map(Student::getAge).reduce(0, Integer::sum);
     

   • 通过sum

     int sum = studentList.stream().mapToInt(Student::getAge).sum();
     

     在上面求和、求最大值、最小值的时候，对于相同操作有不同的方法可以选择执行。

     可以选择collect、reduce、min/max/sum方法，推荐使用min、max、sum方法。因为它最简洁易读，同时通过mapToInt将对象流转换为数值流，避免了装箱和拆箱操作

6. 通过averagingInt求平均值

   double average = studentList.stream().collect(averagingInt(Student::getAge));
   

   如果数据类型为double、long，则通过averagingDouble、averagingLong方法进行求平均

7. 通过summarizingInt同时求总和、平均值、最大值、最小值

   IntSummaryStatistics intSummaryStatistics = studentList.stream().collect(summarizingInt(Student::getAge));
   double average = intSummaryStatistics.getAverage();  //获取平均值
   int min = intSummaryStatistics.getMin();  //获取最小值
   int max = intSummaryStatistics.getMax();  //获取最大值
   long sum = intSummaryStatistics.getSum();  //获取总和
   

   如果数据类型为double、long，则通过summarizingDouble、summarizingLong方法

8. 通过foreach进行元素遍历

   List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
   integerList.stream().forEach(System.out::println);
   

9. 返回集合

   List<String> strings = studentList.stream().map(Student::getName).collect(toList());
   Set<String> sets = studentList.stream().map(Student::getName).collect(toSet());
   

   通过遍历和返回集合的使用发现流只是把原来的外部迭代放到了内部进行，这也是流的主要特点之一。内部迭代可以减少好多代码量。

10. 通过joining拼接流中的元素

    String result = studentList.stream().map(Student::getName).collect(Collectors.joining(", "));
    

    默认如果不通过map方法进行映射处理拼接的toString方法返回的字符串，joining的方法参数为元素的分界符，如果不指定生成的字符串将是一串的，可读性不强

    • 进阶通过groupingBy进行分组

      Map<Type, List<Dish>> result = studentList.stream().collect(groupingBy(Student::getSex));
      

      在collect方法中传入groupingBy进行分组，其中groupingBy的方法参数为分类函数。还可以通过嵌套使用groupingBy进行多级分类

---

3、总结

​ 哈哈，总算是写完了~~（copy完了）~~ ，今天给的导师让我给数据加上前端标签样式，我想了想，之前好像看过一篇关于stream流的文章，当时看完觉得很是神奇，可惜一直没有机会去实践，这次总算是让我逮到机会了~~（就是想试用下学到的新技术）~~ ，于是开始搜搜stream流的简单基本操作，查查资料为了避免忘记，写个blog记录下，方便下次用时快速找到相关文档~~（节省时间）~~

        //判断blockList数组中元素字典的paramet_text值的长度,获取其最大长度
        int labelType = blockList.stream().max(new Comparator<JSONObject>() {
            @Override
            public int compare(JSONObject o1, JSONObject o2) {
                return o1.getStr("paramet_text").length() > o2.getStr("paramet_text").length() ? 1 : (o1.getStr("paramet_text").length() == o2.getStr("paramet_text").length() ? 0 : -1);
            }
        }).get().getStr("paramet_text").length();

贴下今天写的代码，还被导师夸了下（O(∩_∩)O哈哈~） 这段代码应该是不涉密吧(ˇˍˇ) ～

好了，一看时间又到了下班点了，收拾收拾划划水准备下班吧，今天写的代码大概也就20行左右吧，毕竟刚来，还算比较闲

参考文章：链接