Stream流

Posted 2022-02-05 大忽悠爱忽悠

Stream流再整理

• Stream基本API使用
• • 将数组转换为管道流
  • 将集合类对象转换为管道流
  • 将文本文件转换为管道流
• Stream的filter与谓语逻辑
• • 什么是谓词逻辑？
  • 谓词逻辑的复用
  • • and语法（交集）
    • or语法（并集）
    • negate语法（取反）
• Stream管道流的map操作
• • 回顾Stream管道流map的基础用法
  • 处理非字符串类型集合元素
  • 再复杂一点：处理对象数据格式转换
  • flatMap
• Stream的状态与并行操作
• • 中间操作：有状态与无状态
  • Limit与Skip管道数据截取
  • Distinct元素去重
  • Sorted排序
  • 串行、并行与顺序
• Stream性能测试
• • 测试代码
• 像使用SQL一样排序集合
• • 字符串List排序
  • 整数类型List排序
  • 按对象字段对List排序
  • Comparator链对List排序
• 函数式接口Comparator
• • 函数式接口是什么？
  • 函数式接口的特点
  • default关键字
  • JDK中的函数式接口举例
  • 自定义Comparator排序
• Stream查找与匹配元素
• • 举例
  • 其他匹配规则函数介绍
  • 元素查找与Optional
• Stream集合元素归约
• • Integer类型归约
  • String类型归约
  • 复杂对象归约
  • Combiner合并器的使用
  • 并行流数据归约（使用合并器）
• StreamAPI终端操作
• • Java Stream管道数据处理操作
  • ForEach和ForEachOrdered
  • 元素的收集collect
  • • 收集为Set
    • 收集到List
    • 通用的收集方式
    • 收集到Array
    • 收集到Map
    • 分组收集groupingBy
    • 其他常用方法
• java8如何排序Map
• • 学习一下HashMap的merge()函数
  • 按Map的键排序
  • 按Map的值排序
  • 使用TreeMap按键排序
  • Map中的key或value是自定义对象，如何实现map排序
• Stream流逐行文件处理
• • Java 8逐行读取文件
  • Java 8读取文件–过滤行
  • Java 7 –使用FileReader读取文件
• java8-forEach
• • Java 8 forEach 方法
  • • Iterable.forEach()方法
  • Map.forEach()
  • 使用forEach遍历 List的例子
  • 使用forEach 遍历 Map

---

Stream基本API使用

        List<String> nameStrs = Arrays.asList("Monkey", "Lion", "Giraffe","Lemur");

        List<String> list = nameStrs.stream()
                .filter(s -> s.startsWith("L"))
                .map(String::toUpperCase)
                .sorted()
                .collect(toList());
        System.out.println(list);

• 首先，我们使用Stream()函数，将一个List转换为管道流
• 调用filter函数过滤数组元素，过滤方法使用lambda表达式，以L开头的元素返回true被保留，其他的List元素被过滤掉
• 然后调用Map函数对管道流中每个元素进行处理，字母全部转换为大写
• 然后调用sort函数，对管道流中数据进行排序
• 最后调用collect函数toList，将管道流转换为List返回

最终的输出结果是：[LEMUR, LION]。

---

将数组转换为管道流

使用Stream.of()方法，将数组转换为管道流。

        String[] array = "Monkey", "Lion", "Giraffe", "Lemur";
        Stream<String> nameStrs2 = Stream.of(array);

        Stream<String> nameStrs3 = Stream.of("Monkey", "Lion", "Giraffe", "Lemur");

---

将集合类对象转换为管道流

通过调用集合类的stream()方法，将集合类对象转换为管道流。

        List<String> list = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur");
        Stream<String> streamFromList = list.stream();

        Set<String> set = new HashSet<>(list);
        Stream<String> streamFromSet = set.stream();

---

将文本文件转换为管道流

通过Files.lines方法将文本文件转换为管道流，下图中的Paths.get()方法作用就是获取文件，是Java NIO的API！

也就是说：我们可以很方便的使用Java Stream加载文本文件，然后逐行的对文件内容进行处理。

Stream<String> lines = Files.lines(Paths.get("file.txt"));

---

Stream的filter与谓语逻辑

环境搭建

@Data
@AllArgsConstructor
@Builder
public class Employee 

   private Integer id;
   private Integer age;   //年龄
   private String gender;  //性别
   private String firstName;  
   private String lastName;

写一个测试类，这个测试类的内容也很简单，新建十个Employee 对象

     Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
        Employee e2 = new Employee(2,13,"F","Martina","Hengis");
        Employee e3 = new Employee(3,43,"M","Ricky","Martin");
        Employee e4 = new Employee(4,26,"M","Jon","Lowman");
        Employee e5 = new Employee(5,19,"F","Cristine","Maria");
        Employee e6 = new Employee(6,15,"M","David","Feezor");
        Employee e7 = new Employee(7,68,"F","Melissa","Roy");
        Employee e8 = new Employee(8,79,"M","Alex","Gussin");
        Employee e9 = new Employee(9,15,"F","Neetu","Singh");
        Employee e10 = new Employee(10,45,"M","Naveen","Jain");


        List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);

        List<Employee> filtered = employees.stream()
                .filter(e -> e.getAge() > 70 && e.getGender().equals("M"))
                .collect(Collectors.toList());

        System.out.println(filtered);

需要注意的是上面的filter传入了lambda表达式(之前的章节我们已经讲过了)，表达过滤年龄大于70并且男性的Employee员工。输出如下：

[Employee(id=8, age=79, gender=M, firstName=Alex, lastName=Gussin)]

---

什么是谓词逻辑？

下面要说我们的重点了，通过之前的章节的讲解，我们已经知道lambda表达式表达的是一个匿名接口函数的实现。那具体到Stream.filter()中，它表达的是什么呢？看下图：可以看出它表达的是一个Predicate接口，在英语中这个单词的意思是：谓词

什么是谓词逻辑？

WHERE 和 AND 限定了主语employee是什么，那么WHERE和AND语句所代表的逻辑就是谓词逻辑

SELECT *
FROM employee
WHERE age > 70
AND gender = 'M'

---

谓词逻辑的复用

通常情况下，filter函数中lambda表达式为一次性使用的谓词逻辑。如果我们的谓词逻辑需要被多处、多场景、多代码中使用，通常将它抽取出来单独定义到它所限定的主语实体中。

比如：将下面的谓词逻辑定义在Employee实体class中。

public static Predicate<Employee> ageGreaterThan70 = x -> x.getAge() >70;
public static Predicate<Employee> genderM = x -> x.getGender().equals("M");

and语法（交集）

List<Employee> filtered = employees.stream()
        .filter(Employee.ageGreaterThan70.and(Employee.genderM))
        .collect(Collectors.toList());

输出如下：

[Employee(id=8, age=79, gender=M, firstName=Alex, lastName=Gussin)]

---

or语法（并集）

List<Employee> filtered = employees.stream()
        .filter(Employee.ageGreaterThan70.or(Employee.genderM))
        .collect(Collectors.toList());

输出如下：实际上就是年龄大于70的和所有的男性（由于79的那位也是男性，所以就是所有的男性）

[Employee(id=1, age=23, gender=M, firstName=Rick, lastName=Beethovan), Employee(id=3, age=43, gender=M, firstName=Ricky, lastName=Martin), Employee(id=4, age=26, gender=M, firstName=Jon, lastName=Lowman), Employee(id=6, age=15, gender=M, firstName=David, lastName=Feezor), Employee(id=8, age=79, gender=M, firstName=Alex, lastName=Gussin), Employee(id=10, age=45, gender=M, firstName=Naveen, lastName=Jain)]

---

negate语法（取反）

List<Employee> filtered = employees.stream()
        .filter(Employee.ageGreaterThan70.or(Employee.genderM).negate())
        .collect(Collectors.toList());

输出如下：把上一小节代码的结果取反，实际上就是所有的女性

[Employee(id=2, age=13, gender=F, firstName=Martina, lastName=Hengis), Employee(id=5, age=19, gender=F, firstName=Cristine, lastName=Maria), Employee(id=7, age=68, gender=F, firstName=Melissa, lastName=Roy), Employee(id=9, age=15, gender=F, firstName=Neetu, lastName=Singh)]

---

Stream管道流的map操作

回顾Stream管道流map的基础用法

最简单的需求：将集合中的每一个字符串，全部转换成大写！

List<String> alpha = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur");

//不使用Stream管道流
List<String> alphaUpper = new ArrayList<>();
for (String s : alpha) 
    alphaUpper.add(s.toUpperCase());

System.out.println(alphaUpper); //[MONKEY, LION, GIRAFFE, LEMUR]

// 使用Stream管道流
List<String> collect = alpha.stream().map(String::toUpperCase).collect(Collectors.toList());
//上面使用了方法引用，和下面的lambda表达式语法效果是一样的
//List<String> collect = alpha.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());

System.out.println(collect); //[MONKEY, LION, GIRAFFE, LEMUR]

所以map函数的作用就是针对管道流中的每一个数据元素进行转换操作。

---

处理非字符串类型集合元素

map()函数不仅可以处理数据，还可以转换数据的类型。如下：

List<Integer> lengths = alpha.stream()
        .map(String::length)
        .collect(Collectors.toList());

System.out.println(lengths); //[6, 4, 7, 5]

Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
        .mapToInt(String::length)
        .forEach(System.out::println);

输出如下：

6
4
7
5

除了mapToInt。还有maoToLong，mapToDouble等等用法

---

再复杂一点：处理对象数据格式转换

还是使用上一节中的Employee类，创建10个对象。需求如下：

• 将每一个Employee的年龄增加一岁
• 将性别中的“M”换成“male”，F换成Female。

public static void main(String[] args)
    Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
    Employee e2 = new Employee(2,13,"F","Martina","Hengis");
    Employee e3 = new Employee(3,43,"M","Ricky","Martin");
    Employee e4 = new Employee(4,26,"M","Jon","Lowman");
    Employee e5 = new Employee(5,19,"F","Cristine","Maria");
    Employee e6 = new Employee(6,15,"M","David","Feezor");
    Employee e7 = new Employee(7,68,"F","Melissa","Roy");
    Employee e8 = new Employee(8,79,"M","Alex","Gussin");
    Employee e9 = new Employee(9,15,"F","Neetu","Singh");
    Employee e10 = new Employee(10,45,"M","Naveen","Jain");


    List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);

    /*List<Employee> maped = employees.stream()
            .map(e -> 
                e.setAge(e.getAge() + 1);
                e.setGender(e.getGender().equals("M")?"male":"female");
                return e;
            ).collect(Collectors.toList());*/

    List<Employee> maped = employees.stream()
            .peek(e -> 
                e.setAge(e.getAge() + 1);
                e.setGender(e.getGender().equals("M")?"male":"female");
            ).collect(Collectors.toList());

    System.out.println(maped);

由于map的参数e就是返回值，所以可以用peek函数。peek函数是一种特殊的map函数，当函数没有返回值或者参数就是返回值的时候可以使用peek函数

---

flatMap

map可以对管道流中的数据进行转换操作，但是如果管道中还有管道该如何处理？即：如何处理二维数组及二维集合类。实现一个简单的需求：将“hello”，“world”两个字符串组成的集合，元素的每一个字母打印出来。如果不用Stream我们怎么写？写2层for循环,第一层遍历字符串，并且将字符串拆分成char数组，第二层for循环遍历char数组。

List<String> words = Arrays.以上是关于Stream流的主要内容，如果未能解决你的问题，请参考以下文章
 
 Stream消息流 和 Stream Grouping 消息流组
 Stream流体系
 Stream流
 jdk8新特性-Stream流详解及使用样例(Stream创建使用收集并行流注意事项)
 jdk8新特性-Stream流详解及使用样例(Stream创建使用收集并行流注意事项)
 jdk1.8新特性——Stream（流）的创建