Java8新特性（三）集合之 Stream 流式操作

stream就像一条大管套小管的管道，我们不用关心它的源头在哪里，只需要知道我们可以在目的地（海？）可以收集到来自五湖四海的一样。一般情况下，我们也不用管这管道源头在哪里，只需要拿到我们需要的东西。
使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之， Stream API 提供了一种高效且易于使用的处理数据的方式。

---

参考
JDK8新特性(三)：集合之 Stream 流式操作

JDK8辅助学习(四)：Stream流 collect() 方法的详细使用介绍

---

• 一、感受一下
• 二、Stream流常用方法
• 三、实践

---

一、感受一下

Stream是什么？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！ ”

stream的特点：

• Stream 自己不会存储元素。
• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

需求：挑选出年龄大于12岁的学生，并按照年龄从大到小的顺序将它们排成一排。

package com._520xuzai.stream;

import java.util.List;

/**
 * 学生对象
 */
public class Student {

    private Integer id;

    private int age;

    private String name;

    private List<String> courses;

    public Student(int age, String name, List<String> courses) {
        this.age = age;
        this.name = name;
        this.courses = courses;
        this.id = 1;
    }

    public Student(Integer id, int age, String name, List<String> courses) {
        this.id = id;
        this.age = age;
        this.name = name;
        this.courses = courses;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<String> getCourses() {
        return courses;
    }

    public void setCourses(List<String> courses) {
        this.courses = courses;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", courses=" + courses +
                '}';
    }
}

具体实现

package com._520xuzai.stream;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

    private static List<Student> students = new ArrayList<>();


    static {
        for (int i=0;i<20;i++){
            List<String> courses = new ArrayList<>();
            int age = 5+i;
            courses.add("语文");
            courses.add("外语"+age);
            courses.add("高数"+age);
            students.add(new Student(age,"张三_"+age,courses));
        }
    }


    //需求：挑选出年龄大于12岁的学生，并2.按照年龄从大到小的顺序将它们排成一排。
    @Test
    public void testFunction() {

        //Java7(集合)实现
        //使用迭代器筛选元素
        List<Student> studentList = new ArrayList<Student>();
        for (Student student : students) {
            if (student.getAge() > 12) {
                studentList.add(student);
            }
        }

        //使用匿名类对学生进行年龄排序（从大到小）
        Collections.sort(studentList, new Comparator<Student>() {
            public int compare(Student s1, Student s2) {
                return Integer.compare(s2.getAge(), s1.getAge());
            }
        });

        //将排好序的学生排成一排（放到一起）
        List<String> lastStudentList = new ArrayList<>();
        for (Student s : studentList) {
            lastStudentList.add(s.getName());
        }

        System.out.println("普通方式"+lastStudentList);

        //Java8(Stream)实现
        List<String> lastStudentList2 =
                students.stream()
                        .filter(s -> s.getAge() > 12)//挑选出年龄大于12岁的学生
                        .sorted(Comparator.comparing(Student::getAge).reversed())//按照年龄从大到小（默认从小到大）进行排序
                        .map(Student::getName)//提取满足要求的学生的名字
                        .collect(Collectors.toList());//将名字保存到List中

        System.out.println("stream的方式"+lastStudentList2);

    }

    }

二、Stream流常用方法

    /**
     * forEach() 方法用来遍历流中的数据，是一个终结方法。该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。
     * @param action
     */
    void forEach(Consumer<? super T> action);

    /**
     * count() 方法，用来统计集合中的元素个数，是一个终结方法。该方法返回一个 long 值代表元素个数
     * @return
     */
    long count();


    /**
     *  filter() 方法，用于过滤数据，返回符合过滤条件的数据，是一个非终结方法。
     *  我们可以通过 filter() 方法将一个流转换成另一个子集流。
     *  该接口接收一个 Predicate 函数式接口参数(可以是一个 Lambda 或 方法引用) 作为筛选条件
     * @param predicate
     * @return
     */
    Stream<T> filter(Predicate<? super T> predicate);

    /**
     * limit() 方法，用来对 Stream 流中的数据进行截取，只取用前 n 个，是一个非终结方法。
     * 参数是一个 long 型，如果集合当前长度大于参数则进行截取，否则不进行操作。
     * @param maxSize
     * @return
     */
    Stream<T> limit(long maxSize);

    /**
     * 如果希望跳过前几个元素，去取后面的元素，则可以使用 skip()方法，获取一个截取之后的新流
     * @param n
     * @return
     */
    Stream<T> skip(long n);


    /**
     * map() 方法，可以将流中的元素映射到另一个流中。
     * 即：可以将一种类型的流转换为另一种类型的流
     * 可以将当前流中的T类型数据转换为另一种R类型的流
     * @param mapper
     * @param <R>
     * @return
     */
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);


    /**
     *  flatMap 的使用，同 map 类似。
     *  map只是一维 1对1 的映射，而flatMap可以将一个2维的集合映射成一个一维，相当于它映射的深度比map深了一层。
     * @param mapper
     * @param <R>
     * @return
     */
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

    /**
     * 根据元素的自然规律排序
     * @return
     */
    Stream<T> sorted();
    /**
     * 根据比较器指定的规则排序
     * @param comparator
     * @return
     */
    Stream<T> sorted(Comparator<? super T> comparator);

    /**
     * distinct() 方法，可以用来去除重复数据
     * @return
     */
    Stream<T> distinct();



    /**
     * allMatch 全匹配(匹配所有,所有元素都需要满足条件-->返回true)
     * @param predicate
     * @return
     */
    boolean allMatch(Predicate<? super T> predicate);

    /**
     * anyMatch 匹配某个元素(只要有一个元素满足条件即可-->返回true)
     * @param predicate
     * @return
     */
    boolean anyMatch(Predicate<? super T> predicate);

    /**
     * noneMatch 匹配所有元素(所有元素都不满足指定条件-->返回true)
     * @param predicate
     * @return
     */
    boolean noneMatch(Predicate<? super T> predicate);

    /**
     * findFirst() 、findAny() 方法，都是用来查找 Stream 流中的第一个元素。
     * 返回值为 Optional<T>，意味着有可能找到也有可能找不到的情况
     * @return
     */
    Optional<T> findFirst();
    Optional<T> findAny();

    /**
     * max() 和 min() 方法，用来获取 Stream 流中的最大值和最小值。
     * 该接口需要一个 Comparator 函数式接口参数，根据指定排序规则来获取最大值，最小值。
     *为了保证数据的准确性，此处排序规则需要是升序排序。
     * 因为：max() 方法获取的是排序后的最后一个值，min() 方法获取的是排序后的第一个值。
     * @param comparator
     * @return
     */
    Optional<T> max(Comparator<? super T> comparator);
    Optional<T> min(Comparator<? super T> comparator);

三、实践

1、flatmap与map的区别

 @Test
    public void testFlatMap() {

//        Stream<Student> studentStream = students.stream().filter(s -> (s.getAge() > 23 || s.getAge() > 23));


        List<Student> studentList = new ArrayList<>();

        List<String> courses1 = new ArrayList<>();
        courses1.add("语文");
        courses1.add("外语");
        courses1.add("高数");
        studentList.add(new Student(18,"张三",courses1));
        courses1.clear();
        courses1.add("语文");
        courses1.add("物理");
        courses1.add("化学");
        studentList.add(new Student(19,"李四",courses1));

        //使用map,需要多次forEach

        Stream<List<String>> listStream = studentList.stream().map(student -> student.getCourses());
        System.out.println("map1----------");
        studentList.stream().map(student -> student.getCourses()).forEach(System.out::println);
        System.out.println("map2----------");
        studentList.stream().map(student -> student.getCourses().stream().map(s->s.replace("语文","政治"))).forEach(x -> System.out.println(Arrays.toString(x.toArray())));
        System.out.println("map3----------");
        studentList.stream().map(student->student.getCourses()).forEach(courses -> courses.forEach(System.out::println));

        //使用 flatMap,一次forEach即可
        Stream<String> stringStream = studentList.stream().flatMap(student -> student.getCourses().stream());
        System.out.println("flatmap1----------");
        studentList.stream().map(student->student.getCourses()).flatMap(student->student.stream()).forEach(System.out::println);

        System.out.println("flatmap2----------");
        studentList.stream().map(student->student.getCourses()).flatMap(student->student.stream().map(s -> s.replace("语文","政治"))).forEach(System.out::println);

        System.out.println("flatmap3----------");
        studentList.stream().flatMap(student->student.getCourses().stream()).forEach(System.out::println);

         System.out.println("flatmap4----------");
        studentList.stream().flatMap(student->student.getCourses().stream().map(s->s.replace("语文","政治"))).forEach(System.out::println);


    }

输出结果：

map1----------
[语文, 物理, 化学]
[语文, 物理, 化学]
map2----------
[政治, 物理, 化学]
[政治, 物理, 化学]
map3----------
语文
物理
化学
语文
物理
化学
flatmap1----------
语文
物理
化学
语文
物理
化学
flatmap2----------
政治
物理
化学
政治
物理
化学
flatmap3----------
语文
物理
化学
语文
物理
化学
flatmap4----------
政治
物理
化学
政治
物理
化学

2、Collect相关操作

    @Test
    public void testCollect() {

//        Stream<Student> studentStream = students.stream().filter(s -> (s.getAge() > 23 || s.getAge() > 23));


        List<Student> studentList = new ArrayList<>();

        List<String> courses1 = new ArrayList<>();
        courses1.add("语文");
        courses1.add("外语");
        courses1.add("高数");
        studentList.add(new Student(1,18, "张三", courses1));
        courses1.clear();
        courses1.add("语文");
        courses1.add("物理");
        courses1.add("化学");
        studentList.add(new Student(2,18, "李四", courses1));

        //转map，需要指定key和value，Function.identity()表示当前的Emp对象本身
        studentList.stream().collect(Collectors.toMap(Student::getId,Function.identity())).forEach((x,y) -> System.out.println("id="+x+"  __实体信息__"+y));
        //分组操作
        studentList.stream().collect(Collectors.groupingBy(Student::getAge)).forEach((x,y) -> System.out.println("age="+x+"  __实体信息__"+y));
        //分片
        studentList.stream().collect(Collectors.partitioningBy(student -> student.getId() > 1)).forEach((x,y) -> System.out.println("根据id进行分区"+x+"  __实体信息__"+y));

    }

输出：

id=1  __实体信息__Student{age=18, name='张三', courses=[语文, 物理, 化学]}
id=2  __实体信息__Student{age=18, name='李四', courses=[语文, 物理, 化学]}
age=18  __实体信息__[Student{age=18, name='张三', courses=[语文, 物理, 化学]}, Student{age=18, name='李四', courses=[语文, 物理, 化学]}]
根据id进行分区false  __实体信息__[Student{age=18, name='张三', courses=[语文, 物理, 化学]}]
根据id进行分区true  __实体信息__[Student{age=18, name='李四', courses=[语文, 物理, 化学]}]

本文地址：https://blog.csdn.net/qq_39151461/article/details/112099902