Java8新特性-Stream API

一、Stream简介

1.1 Stream API说明

• Stream API(java.util.stream)把真正的函数式编程风格引入到Java中，提供了简单高效的操作
• Stream 是Java8中处理集合的关键抽象概念，它可以指定对集合进行操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作

1.2 什么是Stream

Stream是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。集合存储数据，Stream是对集合元素进行计算

• Stream本省并不存储元素
• Stream不会改变源对象，会返回一个持有结果的新Stream
• Stream是延迟执行的，只有等到需要结果的时候才执行

1.3 Stream操作步骤

• 创建Stream

  一个数据源(如：集合、数组)获取一个流

• 中间操作

  一个中间操作链，可以进行多种操作，对数据源的数据进行处理

• 终止操作

  一旦执行终止操作，就执行中间操作链，并产生结果，之后，创建的流将不能再被使用，如果使用，需要重新创建一个新的流

二、Stream使用

2.1 创建执行流

• 集合创建执行流

  List<User> userList = User.getUserList();
  //创建顺序流
  Stream<User> userStream = userList.stream();
  //创建并行流 中间操作可以并行执行
  Stream<User> userParallelStream = userList.parallelStream();
  

  Collection接口中实现了默认的stream和parallelStream方法,所以Collection的实现类可以直接调用这两个方法

• 通过数组创建执行流

  int[] intArr = {1,2,3,4,5,6};
  IntStream intStream = Arrays.stream(intArr);
  
  int[] longArr = {1,2,3,4,5,6};
  IntStream longStream = Arrays.stream(longArr);
  
  double[] doubleArr = {1.1,2.2,3.3};
  DoubleStream stream = Arrays.stream(doubleArr);
  
  User[] userArr = {new User(1,"zhangsan",25),new User(2,"lisi",26)};
  Stream<User> userStream = Arrays.stream(userArr);
  

  Arrays工具类中提供了静态的stream方法实现,其中基本类型int、long、double的数组返回的是对应与基本类型的执行流

• 通过Stream的of方法创建

  Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
  Stream<Boolean> booleanStream = Stream.of(true, false);
  Stream<Float> floatStream = Stream.of(1.1f, 2.2f, 3.3f);
  

  通过of方法创建基本数据类型的执行流时,返回的基本类型对应的包装类型的执行流

• 通过Stream的iterate()和generate()创建无限流

  Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);
  
  Stream.generate(Math::random).limit(10).forEach(System.out::println);
  

  iterate是通过迭代的方式一直生成数据,其中第一个参数为起始值,后面的lambda表达式为具体的迭代逻辑,如果没有通过后面的limit方法限制,则会一直迭代下去

  generate是通过重复调用lambda表达式来生成数据,如果不加limit限制,也会一直调用里面的lambda表达式

2.2 Stream的中间操作

Stream的中间操作可以连接起来形成一个调用链(流水线)，只有流水线执行了终止操作，中间操作才会执行，否则中间操作不会做任何处理，而是在终止操作时一次性处理，这种方式称为“惰性求值”

• 筛选与切片

  //过滤出年龄大于25的用户,filter的参数是Predicate函数接口的实现
  List<User> userList = User.getUserList();
  userList.stream().filter(user -> user.getAge() >25).forEach(System.out::println);
  

  //限制集合元素的数量,只输出三个用户
  List<User> userList = User.getUserList();
  userList.stream().limit(3).forEach(System.out::println);
  

  //跳过前面指令数量的集合元素,例子中为跳过前两个
  List<User> userList = User.getUserList();
  userList.stream().skip(2).forEach(System.out::println);
  

  //distinct去重,通过流所生成元素的hashCode()和equals()去除重复元素
  List<User> userListDistinct = new ArrayList<User>(){
      {
          new User(1,"lizhi",23);
          new User(1,"lizhi",23);
          new User(1,"lizhi",23);
      }
  };
  userListDistinct.stream().distinct().forEach(System.out::println);
  

  如果Stream流已经执行过了终止操作,再次调用该流的Stream API将会导致异常:java.lang.IllegalStateException: stream has already been operated upon or closed

• 映射

  //通过映射原有Stream的元素映射成新的元素构成的Stream
  List<String> list = Arrays.asList("aa","bb","cc");
  list.stream().map(String::toUpperCase).forEach(System.out::println);
  
  //将user实体集合映射成user的name集合
  List<User> userList = User.getUserList();
  Stream<String> nameStream = userList.stream().map(User::getName);
  nameStream.filter(name -> name.startsWith("li")).forEach(System.out::println);
  
  //flatmap接收一个函数作为参数,将流中的每个值都映射成另一个流,然后将所有流合并成一个流
  Stream<Character> characterStream = list.stream().flatMap(StreamOperateTest::stringFormat);
  characterStream.forEach(System.out::println);
  /** 原始写法 */
  Stream<Stream<Character>> streamStream = list.stream().map(StreamOperateTest::stringFormat);
  streamStream.forEach(stream -> stream.forEach(System.out::println));
  
  public static Stream<Character> stringFormat(String string){
      List<Character> list = new ArrayList<>(8);
      for (Character c: string.toCharArray()) {
          list.add(c);
      }
      return list.stream();
  }
  

  映射将原有的Stream流通过映射关系转换成一个新的Stream流

• 排序

  //默认排序
  List<Integer> integerList = Arrays.asList(12, 95, 32, 2, 95, -2, 35);
  integerList.stream().sorted().forEach(System.out::println);
  
  //自定义排序
  List<User> userList = User.getUserList();
  userList.stream().sorted(Comparator.comparingInt(User::getAge)).forEach(System.out::println);
  

2.3 终止操作

• 查找与匹配

  //检查是否匹配所有元素
  List<User> userList = User.getUserList();
  boolean allMatch = userList.stream().allMatch(user -> user.getAge() > 24);
  
  //检查是否匹配任何一个元素
  boolean anyMatch = userList.stream().anyMatch(user -> user.getAge() > 25);
  
  //检查是否没有匹配的元素
  boolean noneMatch = userList.stream().noneMatch(user -> user.getAge() > 25);
  
  //查找第一个元素
  Optional<User> firstUser = userList.stream().findFirst();
  
  //查找任意一个元素
  Optional<User> anyUser = userList.stream().findAny();
  
  //统计流中元素个数
  long count = userList.stream().count();
  
  //统计流中最大值  如果比较的用户最大年龄有多个时,则任意返回一个
  Optional<User> maxUser = userList.stream().max(Comparator.comparing(User::getAge));
  

• 归约

  //将流中元素反复结合起来,得到一个值
  //计算集合中元素的和  第一个参数为起始值,也参与运算
  List<Integer> integerList = Arrays.asList(5, 6, 8, 22, 72, 365, 85);
  Integer reduce = integerList.stream().reduce(0, Integer::sum);
  
  //不需要初始值反复运算,通过map将User流变成age流
  Optional<Integer> allAge = userList.stream().map(User::getAge).reduce(Integer::sum);
  

• 收集

  //将操作后的数据收集到一个集合中
  List<User> userList = User.getUserList();
  
  List<User> collect = userList.stream().filter(user -> 
                                                user.getAge() > 25).collect(Collectors.toList());
  Set<User> userSet = userList.stream().filter(user -> 
                                             user.getName().startsWith("zhu")).collect(Collectors.toSet());