欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java8 新特性之流式数据处理

程序员文章站 2022-06-05 16:07:24
流中间操作 | 操 作 | 类 型 | 返回类型 | 操作参数 | 函数描述符 | | : : | : : | : : | : : | : : | | filter | 中间 | Stream | Predicate | T boolean | | map | 中间 | Stream | Funct ......

流中间操作

操 作 类 型 返回类型 操作参数 函数描述符
filter 中间 Stream Predicate T -> boolean
map 中间 Stream Function<T ,R> T -> R
limit 中间 Stream
sorted 中间 Stream Comparator (T ,T) -> int
distinct 中间 Stream
flatMap 中间 Stream Function<T ,Stream T -> Stream

终端操作

操作 类型 返回类型 操作参数 函数描述符
forEach 终端 void Consumer T -> void
count 终端 Long
collect 终端 R Collector<T ,A ,R>
anyMatch 终端 boolean Predicate T -> boolean
allMatch 终端 boolean Predicate< T> T -> boolean
noneMatch 终端 boolean Predicate T -> boolean
findAny 终端 Optional
findFirst 终端 Optional
reduce 终端 Optional BinaryOperator (T, T) -> T

Java8 新特性之流式数据处理
Java8 新特性之流式数据处理
Java8 新特性之流式数据处理


Action Start

初始化
@Data
@AllArgsConstructor
public class Employee implements Serializable {

   private static final long serialVersionUID = -8078550089934349371L;

   private Long id;
   /**
    * 姓名
    */
   private String name;
   /**
    * 年龄
    */
   private Integer age;

   /**
    * 部门
    */
   private String department;

   /**
    * 专业
    */
   private String profession;

   /**
    * 地址
    */
   private String Address;
}
public static List<Employee> employees = Collections.unmodifiableList(Arrays.asList(
   new Employee(1L, "张三", 18, "技术开发中心", "计算机科学", "江西南昌"),
   new Employee(2L, "李四", 18, "技术开发中心", "计算机科学", "江西抚州"),
   new Employee(3L, "王五", 22, "人力行政中心", "土木工程", "北京"),
   new Employee(4L, "赵六", 23, "财务管理中心", "经济管理", "广东广州"),
   new Employee(5L, "田七", 28, "财务管理中心", "机械与自动化", "上海"),
   new Employee(5L, "田七", 28, "财务管理中心", "机械与自动化", "上海"),
   new Employee(6L, "孔明", 26, "战略合作事业部", "生化工程", "广东深圳"),
   new Employee(7L, "玄德", 40, "战略合作事业部", "生命科学", "江苏南京"),
   new Employee(8L, "云长", 33, "客户服务部", "社会学", "广东广州"),
   new Employee(9L, "翼德", 28, "智能金融事业部", "经济管理", "江苏南京"),
   new Employee(10L, "鲁肃", 36, "智能金融事业部", "经济管理", "上海")
));

1.0 过滤

  • filter 筛选年龄小于25的员工

    List<Employee> list = employees.stream()
              .filter(employee -> employee.getAge() > 25)
              .collect(Collectors.toList());
  • distinct 筛选重复元素

    List<Employee> list = employees.stream()
                .filter(employee -> employee.getAge() > 25)
                .distinct()
                .collect(Collectors.toList());
  • limit 截断流

List<Employee> list = employees.stream()
           .filter(employee -> employee.getAge() > 25)
           .limit(3)
           .collect(Collectors.toList());
  • skip 跳过元素
List<Employee> list = employees.stream()
               .filter(employee -> employee.getAge() > 25)
               .skip(2)
               .collect(Collectors.toList());

2.0 映射

  • map 获取所有员工的姓名

    List<String> list = employees.stream()
              .map(Employee::getName)
              .collect(Collectors.toList());
  • flatMap 扁平流

    String[] arrays = {"Hello", "World"};
    List<String> list = Arrays.stream(arrays)
                .map(str -> str.split("")) // 映射成为Stream<String[]>
                .flatMap(Arrays::stream) // 扁平化为Stream<String>
                .distinct()
                .collect(Collectors.toList());

3.0 查找和匹配

  • anyMatch 流中是否有一个元素能匹配给定的谓词 返回 boolean

    boolean result = employees.stream()
             .anyMatch(employee -> employee.getAge() == 28);
  • allMatch 流中的所有元素能否符合条件

     boolean result = employees.stream()
             .allMatch(employee -> employee.getAge() < 35);
  • noneMatch 可以确保流中没有任何元素与给定的谓词匹配

    boolean result = employees.stream()
           .noneMatch(employee -> employee.getAge() > 40);
  • findAny 返回当前流中的任意元素

    Optional<Employee> result = employees.stream()
               .filter(employee -> Objects.equals(employee.getProfession(), "计算机科学"))
               .findAny();
  • findFirst 返回当前流中的第一个元素

    Optional<Employee> result = employees.stream()
               .filter(employee -> Objects.equals(employee.getProfession(), "计算机科学"))
               .findFirst();

    你可能会想,为什么会同时有 findFirst 和 findAny 呢?答案是并行。找到第一个元素在并行上限制更多。如果你不关心返回的元素是哪个,请使用 findAny ,因为它在使用并行流时限制较少.

4.0 归约

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 计算数值总合
// 方式一
Integer result1 = numbers.stream().reduce(0, (a, b) -> a + b);
// 方式二
Integer result2 = numbers.stream().reduce(0, Integer::sum);
// 计算最大值
Optional<Integer> min = numbers.stream().reduce(Integer::min);
// 计算最小值
Optional<Integer> min = numbers.stream().reduce(Integer::max);

5.0 收集器

  • eg : 计算 员工总数
long count = employees.stream().count();

Long count = employees.stream().collect(Collectors.counting());
  • eg : 查找 员工中年龄最大的

    Optional<Employee> employee = employees.stream()
              .collect(Collectors.maxBy(Comparator.comparing(Employee::getAge)));
    
    Optional<Employee> employee = employees.stream()
                 .max(Comparator.comparing(Employee::getAge));
  • eg: 员工年龄汇总

    Integer sum = employees.stream()
              .mapToInt(Employee::getAge).sum();
    
    Integer sum = employees.stream()
              .collect(Collectors.summingInt(Employee::getAge));
  • eg : 员工平均值

    Double averaging = employees.stream().collect(Collectors.averagingInt(Employee::getAge))

6.0 分组

  • eg : 员工 按专业进行分组

    Map<String, List<Employee>> map = employees.stream()
              .collect(Collectors.groupingBy(Employee::getProfession));
  • eg : 员工 按专业进行分组 并统计专业人数

    Map<String, Long> map = employees.stream()
              .collect(Collectors.groupingBy(Employee::getProfession, Collectors.counting()));
  • eg : 按专业进行分组 并查找专业中年龄最大的那人

 Map<String, Optional<Employee>> map = employees.stream().collect(
           Collectors.groupingBy(Employee::getProfession,                                                          Collectors.maxBy(Comparator.comparing(Employee::getAge))));
  • eg : 将收集器结果转换成 另一种类型 Collectors.collectingAndThen

    Map<String, Employee> map = employees.stream().collect(
     Collectors.groupingBy(Employee::getProfession,Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparing(Employee::getAge)),Optional::get)));
  • eg : 将收集器映射成具体的对象

    Map<String, Set<Integer>> map = employees.stream().collect(
              Collectors.groupingBy(Employee::getProfession, Collectors.mapping(Employee::getAge, Collectors.toSet())));