java8流—stream

平凡也就两个字: 懒和惰;
成功也就两个字: 苦和勤;
优秀也就两个字: 你和我。
跟着我从0学习JAVA、spring全家桶和linux运维等知识，带你从懵懂少年走向人生巅峰，迎娶白富美！
关注微信公众号【 IT特靠谱 】，每天都会分享技术心得~

java8流—stream

1 java8简介

      Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。java8是一个革命性、稳定性高、功能完备的版本。

      目前基本上所有的公司都用的jdk8版本作为公司java系统的编译、运行环境，这基于jdk8有如下特点或优点：

      （1）jdk8功能完善：jdk8几乎能满足所有java项目开发；

      （2）免费：jdk8是免费的，后续版本如jdk11是收费的，对于很多公司来说性价比很低；

      （3）jdk8新增多个亮点功能：stream流（并行流）处理，lamda表达式、新的日期API和Optional。

2 java8流：stream

2.1 准备测试数据

      我们定义一个方法getUsers()，返回一个User用户对象List集合，用于后续的各个Api测试。

      定义User.java类：

package com.hc.alltest.all.java8.stream;

import java.io.Serializable;
import java.util.List;
import java.util.Objects;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 用户
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable, Comparable {

  /**
   * 用户名
   */
  private String name;

  /**
   * 年龄
   */
  private Integer age;

  /**
   * 兴趣爱好
   */
  private List<String> hobbies;

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    User user = (User) o;
    return Objects.equals(getName(), user.getName());
  }

  @Override
  public int hashCode() {

    return Objects.hash(getName());
  }

  /**
   * 默认排序：age升序
   */
  @Override
  public int compareTo(Object o) {
    User user = (User) o;
    return this.age - user.getAge();
  }
}

      获取用户列表的方法：getUsers()

  /**
   * 获取用户列表
   */
  private static List<User> getUsers() {
    List<User> users = new ArrayList<>();
    users.add(User.builder().name("张三").age(10).hobbies(Arrays.asList("篮球", "乒乓球")).build());
    users.add(User.builder().name("李四").age(30).hobbies(Arrays.asList("游泳", "篮球")).build());
    users.add(User.builder().name("王五").age(20).hobbies(Arrays.asList("小说", "音乐")).build());
    users.add(User.builder().name("小六").age(15).hobbies(Arrays.asList("跑步", "篮球")).build());
    users.add(User.builder().name("李四").age(15).hobbies(Collections.emptyList()).build());
    return users;
  }

2.2 filter筛选

      筛选出集合中年龄大于20岁的用户。

  /**
   * 1.filter：筛选出年龄大于20岁的用户
   */
  private static void filterTest() {
    List<User> users = getUsers();
    users = users.stream()
        .filter(user -> user.getAge() > 20)
        .collect(Collectors.toList());
    log.info("筛选出年龄大于20岁的用户：{}", users);
  }

2.3 distinct去重

      去重（name相同认为是同一用户）。需要重写User.java类的equals()和hashCode()方法。

  /**
   * 2.distinct：去重（name相同认为是同一用户）
   */
  private static void distinctTest() {
    //users集合里面有两个name为“李四”的用户
    List<User> users = getUsers();
    users = users.stream()
        .distinct()
        .collect(Collectors.toList());
    log.info("去重（name相同认为是同一用户）：{}", users);
  }

2.4 count计数

      统计集合元素个数。

  /**
   * 3.count：统计集合元素个数
   */
  private static void countTest() {
    List<User> users = getUsers();
    long count = users.stream()
        .count();
    log.info("集合元素个数：{}", count);
  }

2.5 forEach遍历

      遍历（循环）处理集合所有元素。

  /**
   * 4.forEach：遍历（循环）处理集合所有元素
   */
  private static void forEachTest() {
    List<User> users = getUsers();
    users.stream()
        .forEach(user -> {
          //业务处理
          log.info("遍历当前元素为：{}", user);
        });
  }

2.6 sorted默认排序

      集合元素默认排序（按age升序排序）。User.java类需要实现Comparable接口，并实现接口抽象方法int compareTo(Object o）。

  /**
   * 5.sorted：集合元素默认排序（按age升序排序）
   */
  private static void defaultSortedTest() {
    List<User> users = getUsers();
    users = users.stream()
        .sorted()
        .collect(Collectors.toList());
    log.info("默认排序后：{}", users);
  }

2.7 sorted指定顺序排序

      集合元素指定排序（按age升序排序）。

  /**
   * 6.sorted：集合元素指定排序（按age升序排序）
   */
  private static void specifySortedTest() {
    List<User> users = getUsers();
    users = users.stream()
        //.sorted((u1, u2) -> u1.getAge() - u2.getAge())
        .sorted(Comparator.comparingInt(User::getAge))
        .collect(Collectors.toList());
    log.info("指定排序后：{}", users);
  }

2.8 reversed反序排列

      集合元素指定排序（按age升序排序）,并取反序。

  /**
   * 7.reversed：集合元素指定排序（按age升序排序）,并取反序
   */
  private static void reverseTest() {
    List<User> users = getUsers();
    users = users.stream()
//        .sorted((u1, u2) -> u2.getAge() - u1.getAge())
        .sorted(Comparator.comparingInt(User::getAge).reversed())
        .collect(Collectors.toList());
    log.info("指定排序,并取反序：{}", users);
  }

2.9 findFirst获取第一个元素

      取集合中第一个元素。

  /**
   * 8.findFirst：取集合中第一个元素
   */
  private static void findFirstTest() {
    List<User> users = getUsers();
    User firstUser = users.stream()
        .findFirst()
        .orElse(null);
    log.info("集合中第一个元素为：{}", firstUser);
  }

2.10 findAny获取集合中任意一个元素

      取集合中任意一个元素。

  /**
   * 9.findAny：取集合中任意一个元素
   */
  private static void findAnyTest() {
    List<User> users = getUsers();
    User anyUser = users.stream()
        .findAny()
        .orElse(null);
    log.info("集合中任意一个元素为：{}", anyUser);
  }

2.11 min最小值

     取集合中年龄最小的元素.。

  /**
   * 10.min：取集合中年龄最小的元素
   */
  private static void minTest() {
    List<User> users = getUsers();
    User anyUser = users.stream()
        //.min((u1, u2) -> u1.getAge() - u2.getAge())
        .min(Comparator.comparingInt(User::getAge))
        .orElse(null);
    log.info("集合中年龄最小的元素为：{}", anyUser);
  }

2.12 max最大值

      取集合中年龄最大的元素。

  /**
   * 11.max：取集合中年龄最大的元素
   */
  private static void maxTest() {
    List<User> users = getUsers();
    User anyUser = users.stream()
        //.max((u1, u2) -> u1.getAge() - u2.getAge())
        .max(Comparator.comparingInt(User::getAge))
        .orElse(null);
    log.info("集合中年龄最大的元素为：{}", anyUser);
  }

2.13 anyMatch任意元素匹配

      集合中任意一个元素满足条件，返回true；反之，返回false。

  /**
   * 12.anyMatch：集合中任意一个元素满足条件，返回true；反之，返回false
   */
  private static void anyMatchTest() {
    List<User> users = getUsers();
    boolean matchFlag = users.stream()
        .anyMatch(user -> Objects.equals(user.getName(), "李四"));
    log.info("集合中是否存在名为'李四'的元素：{}", matchFlag);
  }

2.14 allMatch所有元素匹配

      集合中所有元素满足条件，返回true；反之，返回false。

  /**
   * 13.allMatch：集合中所有元素满足条件，返回true；反之，返回false
   */
  private static void allMatchTest() {
    List<User> users = getUsers();
    boolean matchFlag = users.stream()
        .allMatch(user -> user.getAge() > 20);
    log.info("集合中所有元素的年龄是否都大于20岁：{}", matchFlag);
  }

2.15 noneMatch所有元素不匹配

      集合中所有元素都不满足条件，返回true；反之，返回false。

  /**
   * 14.noneMatch：集合中所有元素都不满足条件，返回true；反之，返回false
   */
  private static void noneMatchTest() {
    List<User> users = getUsers();
    boolean matchFlag = users.stream()
        .noneMatch(user -> user.getAge() <= 20);
    log.info("集合中是否所有元素的年龄都不小于等于20岁：{}", matchFlag);
  }

2.16 map集合值映射

       集合值映射。

  /**
   * 15.map：集合值映射
   */
  private static void mapTest() {
    List<User> users = getUsers();
    List<String> names = users.stream()
//        .map(user -> user.getName())
        .map(User::getName)
        .collect(Collectors.toList());
    log.info("集合中所有对象的名称集合为：{}", names);
  }

2.17 flatMap集合值扁平映射

      集合值扁平映射。

  /**
   * 16.flatMap：集合值扁平映射
   */
  private static void flatMapTest() {
    List<User> users = getUsers();
    List<String> allHobbies = users.stream()
        .flatMap(user -> user.getHobbies().stream())
        .collect(Collectors.toList());
    log.info("集合中所有用户的所有兴趣爱好列表：{}", allHobbies);
  }

2.18 map+reduce聚合求值

      聚合求值。

  /**
   * 17.map+reduce：聚合求值
   */
  private static void mapReduceTest() {
    List<User> users = getUsers();
    int ageSum = users.stream()
//        .map(user -> user.getAge())
        .map(User::getAge)
        .reduce(0, (age1, age2) -> age1 + age2);
    log.info("集合中所有用户年龄总和：{}", ageSum);
  }

2.19 parallel并行流

      并行流处理。

  /**
   * 18.parallel：并行流处理
   */
  private static void parallelStreamTest() {
    List<User> users = getUsers();
    //下面两种方式等效
    users.stream()
        .parallel()
        .forEach(user -> {
          //业务处理
          log.info(".stream.parallel并行遍历当前元素为：{}", user);
        });
    users.parallelStream()
        .parallel()
        .forEach(user -> {
          //业务处理
          log.info(".parallelStream并行遍历当前元素为：{}", user);
        });
  }

      关注微信公众号并回复"我要stream源码"，免费获取本教程demo源码、java及其相关视频教程~