Stream流的一些使用方法

一、创建Stream数据流

  1. Stream流创建

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

    List<Integer> integerList = new ArrayList<>();
    integerList.add(0);
    integerList.add(1);
    integerList.add(2);
    integerList.add(3);
    integerList.add(4);
    integerList.add(5);
    Stream<Integer> listStream = integerList.stream();
  3. Arrays创建

    int[] intArr = {0, 1, 2, 3, 4, 5};
    IntStream arrayStream = Arrays.stream(intArr);
  4. 文件创建

    try {
         Stream<String> fileStream = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
    } catch (IOException e) {
         e.printStackTrace();
    }
  5. 函数创建(无限流)

    Stream.iterator() 方法接受两个参数,第一个为初始化值,第二个为进行的函数操作,因为 iterator 生成的流为无限流,通过 limit 方法对流进行了截断

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

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

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

二、Stream流中间操作

  1. filter过滤

    // filter:输出ID大于6的user对象
    List<User> filetrUserList = userList.stream().filter(user -> user.getId() > 6).collect(Collectors.toList());
    filetrUserList.forEach(System.out::println);
    //查找列表中以B开头的第一个字符串
    String result2=names.stream().filter(name->name.startsWith("B")).findFirst().orElse("未找到");
  2. map映射

    map 元素映射,提供一个映射规则,将流中的每一个元素替换成指定的元素

    // map
    List<String> mapUserList = userList.stream().map(user -> user.getName() + "用户").collect(Collectors.toList());
    mapUserList.forEach(System.out::println);
  3. distinct去重

    distinct 去重,去除流中的重复的数据,这个方法是没有参数的,去重的规则与 hashSet 相同

    // 去重
    dataSource.distinct().forEach(System.out::println); 
  4. sorted排序

    sorted 排序,将流中的数据,按照其对应的类实现的 Comparable 接口提供的比较规则进行排序

    // sorted:排序,根据名字倒序
    userList.stream().sorted(Comparator.comparing(User::getName).reversed()).collect(Collectors.toList()).forEach(System.out::println);
    //将集合中所有元素排序并大写输出
    List<String> words= Arrays.asList("banana","apple","orange");
    words.stream().sorted().map(String::toUpperCase).forEach(System.out::println);
  5. limit & skip 限制 & 跳过

    • limit 限制,表示截取流中的指定数量的数据(从第0开始),丢弃剩余部分

    • skip 跳过,表示跳过指定数量的数据,截取剩余部分

    // 获取成绩的[3,5]名
    dataSource.sorted((s1,s2) -> s2.score - s1.score).distinct() 
                .limit(5)
                .skip(2)
                .forEach(System.out::println);
  6. flatMap扁平化映射

    使用 flatMap 方法的效果是,各个数组并不是分别映射成一个流,而是映射成流的内容。所有使用 map(Arrays::stream) 时生成的单个流都被合并起来,即扁平化为一个流

    // 一般是用在map映射完成后,流中的数据是一个容器,而我们需要再对容器中的数据进行处理,此时使用扁平化映射
    // 将字符串数组中的数据读取到流中
    Stream<String> stream = Arrays.stream(s);  
    // 统计字符串数组中所有出现的字符
    stream.map(e -> e.split("")) 
                .flatMap(Arrays::stream)
                .distinct()
                .forEach(System.out::print);
  7. peek对元素进行遍历处理

    // peek:对元素进行遍历处理,每个用户ID加1输出
    userList.stream().peek(user -> user.setId(user.getId()+1)).forEach(System.out::println);

三、Stream流终端操作

Stream 流执行完终端操作之后,无法再执行其他动作,否则会报状态异常,提示该流已经被执行操作或者被关闭,想要再次执行操作必须重新创建 Stream 流

一个流有且只能有一个终端操作,当这个操作执行后,流就被关闭了,无法再被操作,因此一个流只能被遍历一次,若想在遍历需要通过源数据在生成流。

终端操作的执行,才会真正开始流的遍历。如 count、collect 等

  1. collect收集器

    collect 将流中的数据整合起来

    // collect:收集器,将流转换为其他形式
    Set set = userList.stream().collect(Collectors.toSet());
    set.forEach(System.out::println);
    System.out.println("--------------------------");
    List list = userList.stream().collect(Collectors.toList());
    list.forEach(System.out::println);
  2. forEach 遍历流

    forEach 遍历流中数据

    // forEach:遍历流
    userList.stream().forEach(user -> System.out.println(user));
    userList.stream().filter(user -> "上海".equals(user.getCity())).forEach(System.out::println);
  3. findFirst & findAny 获取流中的元素

    findFirst 获取流中的一个元素,获取的是流中的首元素,在进行元素获取的时候,无论是串行流还是并行流,获取的都是首元素

    // findFirst:返回第一个元素
    User firstUser = userList.stream().findFirst().get();
    User firstUser1 = userList.stream().filter(user -> "上海".equals(user.getCity())).findFirst().get();

    findAny 获取流中的一个元素,通常是首元素,但在并行流中,获取的可能不是首元素。在进行元素获取的时候,串行流一定获取到的是流中的首元素,并行流获取到的可能是首元素,也可能不是

    // findAny:将返回当前流中的任意元素
    User findUser = userList.stream().findAny().get();
    User findUser1 = userList.stream().filter(user -> "上海".equals(user.getCity())).findAny().get();
  4. count总数

    count 返回流中元素总数

    // count:返回流中元素总数
    long count = userList.stream().filter(user -> user.getAge() > 20).count();
    System.out.println(count);
  5. sum求和

    // sum:求和
    int sum = userList.stream().mapToInt(User::getId).sum();
    //对集合元素求和
    List<Integer> numbers= Arrays.asList(3,7,2,8,10,1,5,6);
    //第一种方法
    Integer r1=numbers.stream().mapToInt(Integer::intValue).sum();
    //第二种方法
    Integer reduce = numbers.stream().reduce(0, Integer::sum);
  6. max & min 最大 & 最小

    // max:最大值
    int max = userList.stream().max(Comparator.comparingInt(User::getId)).get().getId();
    // min:最小值
    int min = userList.stream().min(Comparator.comparingInt(User::getId)).get().getId();
  7. reduce 聚合

    reduce 将流中的数据按照一定的规则聚合起来

    // reduce:将流中元素反复结合起来,得到一个值
    Optional reduce = userList.stream().reduce((user, user2) -> {
          return user+user2;
    });
    if(reduce.isPresent()) System.out.println(reduce.get());
  8. allMatch & anyMatch & noneMatch

    allMatch: 只有当流中所有的元素都匹配指定的规则,才会返回 true

    anyMatch: 只要流中的任意数据满足指定的规则,就会返回 true

    noneMatch: 只有当流中所有的元素都不满足指定的规则,才会返回 true

    // allMatch:检查是否匹配所有元素
    boolean matchAll = userList.stream().allMatch(user -> "北京".equals(user.getCity()));
    // anyMatch:检查是否至少匹配一个元素
    boolean matchAny = userList.stream().anyMatch(user -> "北京".equals(user.getCity()));
    // noneMatch:检查是否没有匹配所有元素,返回 boolean
    boolean nonaMatch = userList.stream().allMatch(user -> "北京".equals(user.getCity()));

四、Collect收集

Collector:结果收集策略的核心接口,具备将指定元素累加存放到结果容器中的能力;并在Collectors工具中提供了Collector接口的实现类

  1. toList

    将用户 ID 存放到 List 集合中

    List<Integer> idList = userList.stream().map(User::getId).collect(Collectors.toList()) ;
  2. toMap

    将用户 ID 和 Name 以 Key-Value 形式存放到 Map 集合中

    Map<Integer,String> userMap = userList.stream().collect(Collectors.toMap(User::getId,User::getName));
  3. toSet

    将用户所在城市存放到 Set 集合中

    Set<String> citySet = userList.stream().map(User::getCity).collect(Collectors.toSet());
  4. counting

    符合条件的用户总数

    long count = userList.stream().filter(user -> user.getId()>1).collect(Collectors.counting());
  5. sumingInt

    对结果元素即用户 ID 求和

    Integer sumInt = userList.stream().filter(user -> user.getId()>2).collect(Collectors.summingInt(User::getId)) ;

    对集合元素求和

    List<Integer> numbers= Arrays.asList(3,7,2,8,10,1,5,6);
    Integer r=numbers.stream().collect(Collectors.summingInt(Integer::intValue));
  6. minBy

    筛选元素中 ID 最小的用户

    User maxId = userList.stream().collect(Collectors.minBy(Comparator.comparingInt(User::getId))).get() ;
  7. joining

    将用户所在城市,以指定分隔符链接成字符串

    String joinCity = userList.stream().map(User::getCity).collect(Collectors.joining("||"));
  8. groupingBy

    按条件分组,以城市对用户进行分组;

    Map<String,List<User>> groupCity = userList.stream().collect(Collectors.groupingBy(User::getCity));