首页 > 编程语言 > 详细

java8新特性——Stream API

时间:2018-05-21 23:53:17      阅读:62      评论:0      收藏:0      [点我收藏+]

标签:二维   n)   二维数组   asn   数据库   ava   tro   转换   bus   

  Java8中有两大最为重要得改变,其一时Lambda表达式,另外就是 Stream API了。在前面几篇中简单学习了Lambda表达式得语法,以及函数式接口。本文就来简单学习一下Stream API(java.util.stream.*)。

  Stream 是 Java8中处理集合得关键抽象概念,他可以指定你希望对集合进行得操作,可以执行非常复杂得查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作,就类似使用SQL执行得数据库查询。也可以使用S他ream API 来并行执行操作。简而言之,Stream API 提供了一种高效且易于使用得处理数据得方式。

  在Stream操作过程中,可以对数据流做过滤,排序,切片等操作,但是操作之后会产生一个新的流,而数据源则不会发生改变。

 

一、什么是 Stream

  Stream是数据渠道,用于操作数据源(集合,数组等)所生成得元素序列。而集合讲得是数据,流讲得是计算。

  注意:

    ①. Stream 自己不会存储元素。

    ②. Stream 不会改变源对象。相反,它会返回一个持有结果得新Stream

    ③. Stream 操作时延迟执行得,这意味着它们会等到需要结果时才执行。(延迟加载)

 

二、Stream 操作的三个步骤

  1). 创建 Stream

    一个数据源(集合,数组),获取一个流。

  2). 中间操作

    一个中间操作链,对数据源的数据进行处理。

  3). 终止操作

    一个终止操作,执行中间操作链,并产生结果。

 

三、创建Stream 的四种方式

  1). 通过Collection得Stream()方法(串行流)或者 parallelStream()方法(并行流)创建Stream。

 1   /**
 2      * 创建 Stream的四种方式
 3      * 1.通过Collection得Stream()方法(串行流)
 4             或者 parallelStream()方法(并行流)创建Stream
 5      */
 6     @Test
 7     public void test1 () {
 8         
 9         //1. 通过Collection得Stream()方法(串行流)
10         //或者 parallelStream()方法(并行流)创建Stream
11         List<String> list = new ArrayList<String>();
12         Stream<String> stream1 = list.stream();
13         
14         Stream<String> stream2 = list.parallelStream();
15         
16     }

 

  2).通过Arrays中得静态方法stream()获取数组流

 1     /**
 2      * 创建 Stream的四种方式
 3      * 2. 通过Arrays中得静态方法stream()获取数组流
 4      */
 5     @Test
 6     public void test2 () {
 7         
 8         //2. 通过Arrays中得静态方法stream()获取数组流
 9         IntStream stream = Arrays.stream(new int[]{3,5});
10         
11     }

 

  3). 通过Stream类中得 of()静态方法获取流

 1     /**
 2      * 创建 Stream的四种方式
 3      * 3. 通过Stream类中得 of()静态方法获取流
 4      */
 5     @Test
 6     public void test3 () {
 7         
 8         //3. 通过Stream类中得 of()静态方法获取流
 9         Stream<String> stream = Stream.of("4645", "huinnj");
10         
11     }

 

  4). 创建无限流(迭代、生成)

 1 /**
 2      * 创建 Stream的四种方式
 3      * 4. 创建无限流(迭代、生成)
 4      */
 5     @Test
 6     public void test4 () {
 7         
 8         //4. 创建无限流
 9         //迭代(需要传入一个种子,也就是起始值,然后传入一个一元操作)
10         Stream<Integer> stream1 = Stream.iterate(2, (x) -> x * 2);
11         
12         //生成(无限产生对象)
13         Stream<Double> stream2 = Stream.generate(() -> Math.random());
14         
15     }

 

四、Stream 中间操作

  多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何得处理!而终止操作时一次性全部处理,称为‘延迟加载’

  1). 筛选与切片

    ①. filter —— 接收Lambda ,从流中排除某些元素。

 1     /**
 2      * 筛选与切片
 3      *  filter —— 接收Lambda ,从流中排除某些元素。
 4      *  
 5      */
 6     @Test
 7     public void test5 () {
 8         //内部迭代:在此过程中没有进行过迭代,由Stream api进行迭代
 9         //中间操作:不会执行任何操作
10         Stream<Person> stream = list.stream().filter((e) -> {
11             System.out.println("Stream API 中间操作");
12             return e.getAge() > 30;
13         });
14         
15         //终止操作:只有执行终止操作才会执行全部。即:延迟加载 
16         stream.forEach(System.out :: println);
17     
18     }

  执行上面方法,得到下面结果。

Person [name=张三, sex=男, age=76]
Stream API 中间操作
Stream API 中间操作
Person [name=王五, sex=男, age=35]
Stream API 中间操作
Stream API 中间操作
Person [name=钱七, sex=男, age=56]
Stream API 中间操作
Person [name=翠花, sex=女, age=34]

  我们,在执行终止语句之后,一边迭代,一边打印,而我们并没有去迭代上面集合,其实这是内部迭代,由Stream API 完成。

  下面我们来看看外部迭代,也就是我们人为得迭代。

1   @Test
2     public void test6 () {
3         //外部迭代
4         Iterator<Person> it = list.iterator();
5         while (it.hasNext()) {
6             System.out.println(it.next());
7         }
8     
9     }

 

    ②. limit —— 截断流,使其元素不超过给定数量。

 

 1     /**
 2      * limit —— 截断流,使其元素不超过给定数量。
 3      */
 4     @Test
 5     public void test7 () {
 6         //过滤之后取2个值
 7         list.stream().filter((e) -> e.getAge() >30 ).
 8         limit(2).forEach(System.out :: println);
 9     
10     }

  在这里,我们可以配合其他得中间操作,并截断流,使我们可以取得相应个数得元素。而且在上面计算中,只要发现有2条符合条件得元素,则不会继续往下迭代数据,可以提高效率。

 

  2). 跳过元素

    skip(n),返回一个扔掉了前n个元素的流。若流中元素不足n个,则返回一个空,与limit(n)互补。

 1     /**
 2      * skip(n)—— 跳过元素,返回一个扔掉了前n个元素的流。
 3      * 若流中元素不足n个,则返回一个空,与limit(n)互补。
 4      */
 5     @Test
 6     public void test8 () {
 7         //跳过前2个值
 8         list.stream().skip(2).forEach(System.out :: println);
 9     
10     }
11      

 

   3).  筛选

    distinct 通过流所生成元素的hashCode()和equals()去除重复元素

 

1     /**
2      * distinct —— 筛选,通过流所生成元素的hashCode()和equals()去除重复元素
3      */
4     @Test
5     public void test9 () {
6         
7         list.stream().distinct().forEach(System.out :: println);
8     
9     }

 

  注意:distinct 需要实体中重写hashCode()和 equals()方法才可以使用

 

  4). 映射

    ① . map ,将元素转换成其他形式或者提取信息。接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。

 

 1     /**
 2      * map —— 映射 ,将元素转换成其他形式或者提取信息。接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
 3      */
 4     @Test
 5     public void test10 () {
 6         //将流中每一个元素都映射到map的函数中,每个元素执行这个函数,再返回
 7         List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
 8         list.stream().map((e) -> e.toUpperCase()).forEach(System.out::printf);
 9     
10         //获取Person中的每一个人得名字name,再返回一个集合
11         List<String> names = this.list.stream().map(Person :: getName).
12             collect(Collectors.toList());
13     }

 

 

    ② . flatMap —— 接收一个函数作为参数,将流中的每个值都换成一个流,然后把所有流连接成一个流

 

 

 1     /**
 2      * flatMap —— 接收一个函数作为参数,将流中的每个值都换成一个流,然后把所有流连接成一个流
 3      */
 4     @Test
 5     public void test11 () {
 6         StreamAPI_Test s = new StreamAPI_Test();
 7         List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
 8         list.stream().flatMap((e) -> s.filterCharacter(e)).forEach(System.out::println);
 9         
10         //如果使用map则需要这样写
11         list.stream().map((e) -> s.filterCharacter(e)).forEach((e) -> {
12             e.forEach(System.out::println);
13         });
14     }
15     
16     /**
17      * 将一个字符串转换为流
18      * @param str
19      * @return
20      */
21     public Stream<Character> filterCharacter(String str){
22         List<Character> list = new ArrayList<>();
23         for (Character ch : str.toCharArray()) {
24             list.add(ch);
25         }
26         return list.stream();
27     }

 

  其实map方法就相当于Collaction的add方法,如果add的是个集合得话就会变成二维数组,而flatMap 的话就相当于Collaction的addAll方法,参数如果是集合得话,只是将2个集合合并,而不是变成二维数组。

 

  5). 排序

     sorted有两种方法,一种是不传任何参数,叫自然排序,还有一种需要传Comparator 接口参数,叫做定制排序。

 

 

 1     /**
 2      * sorted有两种方法,一种是不传任何参数,叫自然排序,还有一种需要传Comparator 接口参数,叫做定制排序。
 3      */
 4     @Test
 5     public void test12 () {
 6         // 自然排序
 7         List<Person> persons = list.stream().sorted().collect(Collectors.toList());
 8         
 9         //定制排序
10         List<Person> persons1 = list.stream().sorted((e1, e2) -> {
11             if (e1.getAge() == e2.getAge()) {
12                 return 0;
13             } else if (e1.getAge() > e2.getAge()) {
14                 return 1;
15             } else {
16                 return -1;
17             }
18         }).collect(Collectors.toList());
19     }

 

 

 

五、Stream 终止操作

  1). 查找与匹配

    首先我们先创建一个集合。

 

 1         List<Person> persons = Arrays.asList(
 2             new Person("张三", "男", 76, Status.FREE),
 3             new Person("李四", "女", 12, Status.BUSY),
 4             new Person("王五", "男", 35, Status.BUSY),
 5             new Person("赵六", "男", 3, Status.FREE),
 6             new Person("钱七", "男", 56, Status.BUSY),
 7             new Person("翠花", "女", 34, Status.VOCATION),
 8             new Person("翠花", "女", 34, Status.FREE),
 9             new Person("翠花", "女", 34, Status.VOCATION)
10             );

 

    ①. allMatch —— 检查是否匹配所有元素。

 

1     /**
2      * allMatch —— 检查是否匹配所有元素。
3      * 判断所有状态是否都是FREE
4      */
5     @Test
6     public void test13 () {
7          boolean b = persons.stream().allMatch((e) -> Status.FREE.equals(e.getStatus()));
8          System.out.println(b);
9     }

 

 

 

    ②. anyMatch —— 检查是否至少匹配所有元素。

 

1     /**
2      * anyMatch —— 检查是否至少匹配所有元素。
3      * 判断是否有一个是FREE
4      */
5     @Test
6     public void test14 () {
7          boolean b = persons.stream().anyMatch((e) -> Status.FREE.equals(e.getStatus()));
8          System.out.println(b);
9     }

 

 

 

    ③. noneMatch —— 检查是否没有匹配所有元素。

 

1     /**
2      * noneMatch —— 检查是否没有匹配所有元素。
3      * 判断是否没有FREE
4      */
5     @Test
6     public void test15 () {
7          boolean b = persons.stream().noneMatch((e) -> Status.FREE.equals(e.getStatus()));
8          System.out.println(b);
9     }

 

 

 

    ④. findFirst —— 返回第一个元素。

 

 1     /**
 2      * findFirst —— 返回第一个元素。
 3      *
 4      */
 5     @Test
 6     public void test16 () {
 7          Optional<Person> person = persons.stream().findFirst();
 8          System.out.println(person);
 9          
10          person.orElse(new Person("王五", "男", 35, Status.BUSY));
11     }

 

  注意:上面findFirst 返回的是一个Optional的对像,他将我们的Person封装了一层,这是为了避免空指针。而且这个对象为我们提供了一个orElse方法,就是当我们得到的这个对象为空时,我们可以传入一个新得对象去替代它。

 

 

    ⑤. findAny —— 返回当前流中任意元素。

 

 1     /**
 2      * findAny —— 返回当前流中任意元素。
 3      */
 4     @Test
 5     public void test17 () {
 6          Optional<Person> person = persons.stream().findAny();
 7          System.out.println(person);
 8          
 9          person.orElse(new Person("王五", "男", 35, Status.BUSY));
10     }

 

 

 

    ⑥. count —— 返回流中元素总个数。

 

1     /**
2      * count —— 返回流中元素总个数。
3      */
4     @Test
5     public void test18 () {
6          long count = persons.stream().count();
7          System.out.println(count);
8          
9     }

 

 

 

    ⑦. max —— 返回流中最大值。

 

1     /**
2      * max —— 返回流中最大值。
3      */
4     @Test
5     public void test18 () {
6         Optional<Person> person = persons.stream().max((e1, e2) -> Double.compare(e1.getAge(), e2.getAge()));
7          System.out.println(person);
8          
9     }

 

 

 

    ⑧. min —— 返回流中最小值。

 

1     /**
2      * min —— 返回流中最小值。
3      */
4     @Test
5     public void test20 () {
6         Optional<Person> person = persons.stream().min((e1, e2) -> Double.compare(e1.getAge(), e2.getAge()));
7          System.out.println(person);
8          
9     }

 

  2). 归约(可以将流中元素反复结合在一起,得到一个值)

    ①. reduce(T identitty,BinaryOperator)首先,需要传一个起始值,然后,传入的是一个二元运算。

1     /**
2      * reduce(T identitty,BinaryOperator)首先,需要传一个起始值,然后,传入的是一个二元运算。
3      */
4     @Test
5     public void test21 () {
6         List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
7         Integer sum = list.stream().reduce(0, (x, y) -> x + y);
8     }

 

    ②. reduce(BinaryOperator)此方法相对于上面方法来说,没有起始值,则有可能结果为空,所以返回的值会被封装到Optional中。

1     /**
2      *  reduce(BinaryOperator)此方法相对于上面方法来说,没有起始值,则有可能结果为空,所以返回的值会被封装到Optional中
3      */
4     @Test
5     public void test22 () {
6         List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
7         Optional<Integer> sum = list.stream().reduce(Integer :: sum);
8     }

 

  备注:map和reduce的连接通常称为map-reduce模式,因Google用它来进行网络搜索而出名。

 

  3). 收集collect(将流转换为其他形式。接收一个Collector接口得实现,用于给其他Stream中元素做汇总的方法)

    Collector接口中方法得实现决定了如何对流执行收集操作(如收集到List,Set,Map)。但是Collectors实用类提供了很多静态方法,可以方便地创建常见得收集器实例。

    ①. Collectors.toList() 将流转换成List

1     /**
2      *  Collectors.toList() 将流转换成List
3      */
4     @Test
5     public void test23() {
6         7         List<String> names = this.list.stream().map(Person :: getName).collect(Collectors.toList());
8     }

 

    ②. Collectors.toSet()将流转换为Set

1     /**
2      *  Collectors.toSet() 将流转换成Set
3      */
4     @Test
5     public void test24() {
6         7         Set<String> names = this.list.stream().map(Person :: getName).collect(Collectors.toSet());
8     }

 

    ③. Collectors.toCollection()将流转换为其他类型的集合

1     /**
2      *  Collectors.toCollection()将流转换为其他类型的集合
3      */
4     @Test
5     public void test25() {
6         7         LinkedList<String> names =  this.list.stream().map(Person :: getName).collect(Collectors.toCollection(LinkedList :: new));
8     }

    

    ④. Collectors.counting()  元素个数

1     /**
2      *  Collectors.counting()  总数
3      */
4     @Test
5     public void test26() {
6         List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
7         Long count =  list.stream().collect(Collectors.counting());
8     }

 

    ⑤. Collectors.averagingDouble()、Collectors.averagingDouble()、Collectors.averagingLong() 平均数,这三个方法都可以求平均数,不同之处在于传入得参数类型不同,返回值都为Double

 1     /**
 2      *  Collectors.averagingInt() 、
 3      *   Collectors.averagingDouble()、
 4      *    Collectors.averagingLong() 平均数,
 5      *    者三个方法都可以求平均数,不同之处在于传入得参数类型不同,
 6      *    返回值都为Double
 7      */
 8     @Test
 9     public void test27() {
10         List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
11         Double avg =  list.stream().collect(Collectors.averagingInt((x) -> x));
12     }

 

    ⑥. Collectors.summingDouble()、Collectors.summingDouble()、Collectors.summingLong() 求和,不同之处在于传入得参数类型不同,返回值为Integer, Double, Long

 1     /**
 2      *  Collectors.summingInt() 、
 3      *   Collectors.summingDouble()、
 4      *    Collectors.summingLong() 求和,
 5      *    者三个方法都可以求总数,不同之处在于传入得参数类型不同,
 6      *    返回值为Integer, Double, Long
 7      */
 8     @Test
 9     public void test28() {
10         List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
11         Integer sum =  list.stream().collect(Collectors.summingInt((x) -> x));
12     }

 

  ⑦. Collectors.maxBy() 求最大值

1     /**
2      * Collectors.maxBy() 求最大值
3      */
4     @Test
5     public void test29() {
6         List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
7         Optional<Integer> max =  list.stream().collect(Collectors.maxBy((x, y) ->Integer.compare(x, y)));
8     }

 

  ⑧. Collectors.minBy() 求最小值

/**
     * Collectors.minBy() 求最小值
     */
    @Test
    public void test29() {
        List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Optional<Integer> min =  list.stream().collect(Collectors.minBy((x, y) ->Integer.compare(x, y)));
    }

 

  ⑨. Collectors.groupingBy()分组 ,返回一个map

1     /**
2      * Collectors.groupingBy()分组 ,返回一个map
3      */
4     @Test
5     public void test30() {
6         Map<String, List<Person>> personMap =  list.stream().collect(Collectors.groupingBy(Person :: getSex));
7     }

      Collectors.groupingBy()还可以实现多级分组

1     /**
2      * Collectors.groupingBy()多级分组 ,返回一个map
3      */
4     @Test
5     public void test31() {
6         Map<String, Map<Status, List<Person>>> personMap =  list.stream().collect(Collectors.groupingBy(Person :: getSex, Collectors.groupingBy(Person :: getStatus)));
7     }

 

  ⑩. Collectors.partitioningBy() 分区,参数中传一个函数,返回true,和false 分成两个区

1     /**
2      * Collectors.partitioningBy() 分区,参数中传一个函数,返回true,和false 分成两个区
3      */
4     @Test
5     public void test32() {
6         Map<Boolean, List<Person>> personMap =  list.stream().collect(Collectors.partitioningBy((x) -> x.getAge() > 30));
7     }

 

  上面就是Stream的一些基本操作,只要勤加练习就可以灵活使用,而且效率大大提高。

 

java8新特性——Stream API

标签:二维   n)   二维数组   asn   数据库   ava   tro   转换   bus   

原文:https://www.cnblogs.com/wuyx/p/9038768.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号