devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java- Stream API_java stream api

作者：AllinToyou | 2024-05-12 22:50:03

赞

踩

java stream api

目录

Stream Api 特点

一、 Stream 实例化 三种方式

二 、中间操作 

1. 筛选与切片

2.映射

3.排序 

 三、终止操作

1.匹配与查找

2.归约

3.收集

四、Optional  

 1.Optional描述

 2.常用方法

Stream Api 特点

* 使用 Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。
* 也可以使用Strem API 来并行执行操作。
* Stream API 提供一种高效且易于使用的处理数据方式。

一、 Stream 实例化 三种方式

 举个栗子：

  1.   //Stream 实例化方法
  2.  
  3.         List<Person> list = new ArrayList<>();
  4.         list.add(new Person("Tome", 12));
  5.         list.add(new Person("Jack", 43));
  6.         //方式1：通过集合
  7.         Stream<Person> stream = list.stream();//顺序流
  8.         Stream<Person> personStream = list.parallelStream();//并行流
  9.  
  10.         //方式2：通过数组
  11.         int[] arr = new int[]{1, 4, 2, 4, 232, 4, 5};
  12.         IntStream stream1 = Arrays.stream(arr); //数组流
  13.  
  14.  
  15.         //方式3：通过Stream 的of()
  16.         //public static<T> Stream<T> of(T... values) : 返回一个流
  17.         Stream<Integer> stream2 = Stream.of(23, 4, 23, 24, 5, 5, 3);

二 、中间操作 

1. 筛选与切片

  1.     /**
  2.      * 中间操作可以多个操作连成一个流水线，除非流水线触发终止操作，
  3.      * 否则中间操作不会执行任何的处理。而在终止操作一次性全部处理。 “惰性求值”
  4.      * 1.筛选和切片
  5.      */
  6.     @Test
  7.     public void test3(){
  8.        /* list.add(new Employee(1001, "马化腾", 34, 6000.38));
  9.         list.add(new Employee(1002, "马云", 12, 9876.12));
  10.         list.add(new Employee(1003, "刘强东", 33, 3000.82));
  11.         list.add(new Employee(1004, "雷军", 26, 7657.37));
  12.         list.add(new Employee(1005, "李彦宏", 65, 5555.32));
  13.         list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
  14.         list.add(new Employee(1007, "任正非", 26, 4333.32));
  15.         list.add(new Employee(1008, "扎克伯格", 35, 2500.32));*/
  16.  
  17.         List<Employee> list = EmployeeData.getEmployees();
  18.         //筛选和切片
  19.         // filter(Predicate p) 接收Lambda ，从流中排除某些元素
  20.         Stream<Employee> stream = list.stream();
  21.         /*stream.filter(new Predicate<Employee>() {
  22.             @Override
  23.             public boolean test(Employee e) {
  24.                 return e.getSalary() > 7000;
  25.             }
  26.         });
  27.         stream = list.stream();*/
  28.         System.out.println("--------------所有员工列表-----------------------");
  29.         stream.forEach(System.out::println);  //调用终止操作才会执行
  30.         stream = list.stream(); // stream 执行完已经关闭，下面需要使用，重新获取
  31.         //获取 工资大于7000 员工
  32.         System.out.println("------- 工资大于7000 员工-----------------------------");
  33.         stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
  34.  
  35.         //获取 名字大于4个字的 员工
  36.         stream  = list.stream();
  37.         System.out.println("--------- 名字大于4个字的 员工----------------------------");
  38.         stream.filter(employee -> employee.getName().length() >3).forEach(System.out::println);
  39.  
  40. //-----------------------------------------------
  41.  
  42.         //limit（n）； 截断流  使元素不超过给定数量   获取结合前n个元素
  43.         System.out.println("--------- 获取前三个员工信息----------------------------");
  44.         stream = list.stream();
  45.         stream.limit(3).forEach(System.out::println);
  46. //-----------------------------------------------
  47.         //skip（n): 跳过元素，返回一个扔掉前n个元素的流。若流中元素不足n个，返回一个空流
  48.         System.out.println("--------- 获取4个之后的元素----------------------------");
  49.         list.stream().skip(4).forEach(System.out::println);
  50.         System.out.println("--------- 当跳过元素，大于集合中元素，返回空流----------");
  51.         list.stream().skip(list.size()).forEach(System.out::println);
  52. //-----------------------------------------------
  53.         //distinct() -筛选 ，通过流所生成的元素的hashCode() 和 equals() 去除重复
  54.         list.stream().distinct().forEach(System.out::println);
  55.  
  56.     }

2.映射

  1.  //映射
  2.     @Test
  3.     public void test4(){
  4.         //map(Function f)  接收一个函数作为参数，该函数会被应用到每个元
  5.         //素上，并将其映射成一个新的元素。（会把多个元素的流当作一个元素）
  6.         List<Employee> list = EmployeeData.getEmployees();
  7.         Stream<Employee> stream = list.stream();
  8.  
  9.        /* stream.map(new Function<Employee, Object>() {
  10.             @Override
  11.             public Object apply(Employee employee) {
  12.                 return null;
  13.             }
  14.         });*/
  15.        System.out.println("-------------------所有人工资都涨100000------------------------------");
  16.         stream.map(employee -> employee.getSalary() +100000 ).forEach(System.out::println);
  17.         //106000.38   109876.12  103000.82  107657.37   105555.32    109500.43
  18.         System.out.println("-------------------所有姓名长度大于3的员工姓名------------------------------");
  19.         Stream<String> namesStream = list.stream().map(Employee::getName);
  20.         namesStream.filter(name->name.length() >3).forEach(System.out::println);
  21.  
  22. //       list.stream().map(Employee::getName).filter(name ->name.length() >3).forEach(System.out::println);
  23. //    ---------------------------------------------
  24.         // flatMap();接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
  25.

3.排序 

  1.  @Test
  2.     public void test5(){
  3.         //排序
  4.         //1.sorted();  自然排序    产生一个新流，其中按自然顺序排序
  5.         List<Integer> list = Arrays.asList(12, 34, 67, 3, 6, 125);
  6.         list.stream().sorted().forEach(System.out::println);
  7.  
  8.         //2.sorted(Comparator com) 定制排序；  产生一个新流，其中按比较器顺序排序
  9.         List<Employee> list1 = EmployeeData.getEmployees();
  10.         list1.stream().sorted(new Comparator<Employee>() {
  11.             @Override
  12.             public int compare(Employee o1, Employee o2) {
  13.                 if (Double.compare(o1.getSalary(), o2.getSalary()) == 0) {
  14.                     return Integer.compare(o1.getId(), o2.getId());
  15.                 }else {
  16.                     return Double.compare(o1.getSalary(), o2.getSalary());
  17.                 }
  18.             }
  19.         });
  20.         list1.stream().sorted((o1,o2)->{
  21.             if (Double.compare(o1.getSalary(), o2.getSalary()) == 0) {
  22.                 return Integer.compare(o1.getId(), o2.getId());
  23.             }else {
  24.                 return Double.compare(o1.getSalary(), o2.getSalary());
  25.             }
  26.         }).forEach(System.out::println);
  27.  
  28.  
  29.  
  30.     }

 三、终止操作

      1.匹配与查找

  1.  //终止操作
  2.  
  3.     @Test
  4.     public  void test6(){
  5.         //匹配与查找
  6.         List<Employee> list = EmployeeData.getEmployees();
  7.  
  8. //        allMatch(Predicate p) 检查是否匹配所有元素
  9.         System.out.println("-------是否所有员工年龄都大于18-----------------------");
  10.         boolean isAllMatch = list.stream().allMatch(e -> e.getAge() > 18);
  11.         System.out.println(isAllMatch);
  12.  
  13. //        anyMatch(Predicate p) 检查是否至少匹配一个元素
  14.         System.out.println("-------判断至少一个员工工资大于10000-----------------------");
  15.         boolean b = list.stream().anyMatch(e -> e.getSalary() > 10000);
  16.         System.out.println(b);
  17.  
  18. //        noneMatch(Predicate p) 检查是否没有匹配所有元素
  19.         System.out.println("-------判断是由有员工姓 雷-----------------------");
  20.         boolean isLei= list.stream().noneMatch(e -> e.getName().contains("雷"));
  21.         System.out.println(isLei);
  22.  
  23. //        findFirst() 返回第一个元素
  24.         System.out.println(list.stream().findFirst());
  25.  
  26. //        findAny() 返回当前流中的任意元素
  27.         Optional<Employee> any = list.stream().findAny();
  28.         System.out.println(any);
  29.         System.out.println("----------------------------------------");
  30. //        count() 返回流中元素总数
  31.         long count = list.stream().count();
  32.         System.out.println(count);
  33.  
  34. //        max(Comparator c) 返回流中最大值
  35.         System.out.println("--------最高的工资---------------");
  36.         Stream<Double> doubleStream = list.stream().map(e -> e.getSalary());
  37.         Optional<Double> max = doubleStream.max(Double::compare);
  38.         System.out.println(max);
  39.  
  40. //        min(Comparator c) 返回流中最小值
  41. //        forEach(Consumer c)
  42. //        内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。
  43. //        相反，Stream API 使用内部迭代——它帮你把迭代做了)
  44.  
  45.  
  46.  
  47.     }

2.归约

  1.   @Test//规约
  2.     public void test7() {
  3.  
  4.         //reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 T
  5.         // reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
  6.         System.out.println("-----员工所有工资和------------------");
  7.         List<Employee> list = EmployeeData.getEmployees();
  8.         Stream<Double> doubleStream = list.stream().map(Employee::getSalary);
  9.         Double reduce = doubleStream.reduce(0.0, Double::sum);
  10.         System.out.println(reduce);
  11.  
  12.  
  13.     }

 3.收集

  1.         //收集
  2. //        collect(Collector c)  将流转换为其他形式。
  3. //        接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
  4.         List<Employee> list = EmployeeData.getEmployees();
  5.         List<Employee> list1 = list.stream().filter(e -> e.getSalary() > 4000).collect(Collectors.toList());
  6.         Set<Employee> set = list.stream().filter(e -> e.getSalary() > 4000).collect(Collectors.toSet());
  7.         list1.forEach(System.out::println);

四、Optional  

 1.Optional描述

  1. 1.Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表
  2.   这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存
  3.   在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
  4.  
  5. 2. Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则
  6.    isPresent()方法会返回true，调用get()方法会返回该对象。

 2.常用方法

  1. /*创建Optional类对象的方法：
  2.      Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
  3.      Optional.empty() : 创建一个空的 Optional 实例
  4.      Optional.ofNullable(T t)：t可以为null*/
  5.  
  6.  
  7.         Person p = new Person();
  8.         //Optional.of(T t)  t 对象不能为空
  9.         Optional<Person> p0 = Optional.of(new Person());
  10.  
  11.         //Optional.ofNullable(T t)  t 对象可以为空，得到的 p1 也会为空
  12.         p = null;
  13.         Optional<Person> p1 = Optional.ofNullable(p);
  14.         System.out.println(p1); //Optional.empty
  1.  @Test
  2.     public void test2() {
  3.        /* 判断Optional容器中是否包含对象：
  4.         boolean isPresent() : 判断是否包含对象
  5.         void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer 接口的实现代码，并且该值会作为参数传给它。*/
  6.  
  7.         Person p = new Person();
  8.         Optional<Person> person = Optional.ofNullable(p);
  9.         //判断是否Optional 中是否包含Person 的对象
  10.         boolean present = person.isPresent();
  11.         
  12.         person.ifPresent(new Consumer<Person>() {
  13.             @Override
  14.             public void accept(Person person) {
  15.                 
  16.             }
  17.         });
  18.         person.ifPresent((o)->{
  19.             System.out.println("");
  20.         });
  21.         
  22.         person.ifPresent(System.out::println);
  23.     }

  1.   @Test
  2.     public  void test3() throws Throwable {
  3.         /*获取Optional容器的对象：
  4.             T get(): 如果调用对象包含值，返回该值，否则抛异常
  5.             T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
  6.             T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
  7.             T orElseThrow(Supplier<? extends X> exceptionSupplier) ：
  8.                     如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
  9.          */
  10.  
  11.         Optional<Person> optional = Optional.ofNullable(new Person());
  12. //        T get(): 如果调用对象包含值，返回该值，否则抛异常
  13.         Person person = optional.get();
  14.  
  15. //        T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
  16.         Person person1 = optional.orElse(new Person());
  17.  
  18. //        T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
  19.         optional.orElseGet(new Supplier<Person>() {
  20.             @Override
  21.             public Person get() {
  22.                 return new Person();
  23.             }
  24.         });
  25.         Person person2 = optional.orElseGet(() -> new Person());
  26.         Person person3 = optional.orElseGet(Person::new);
  27.  
  28. //        T orElseThrow(Supplier<? extends X> exceptionSupplier) ：
  29. //        如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
  30.         optional.orElseThrow(new Supplier<Throwable>() {
  31.             @Override
  32.             public Throwable get() {
  33.                 return new Exception();
  34.             }
  35.         });
  36.         Person person4 = optional.orElseThrow(() -> new Exception());
  37.         Person person5 = optional.orElseThrow(Exception::new);
  38.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/560858
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号