Java 8中引入的新特性，stream流通过与Lambda表达式结合，采用函数式编程，简化数组、集合操作，提高效率。

我们操作一个集合，就把他看作一个流，整个流依次执行，（可以类比为一个管道）

开始管道：

​

中间管道：

​

 终止管道：

实例：

先创建一个User类：

package One_Thirty;

public class User {
    private int id;
    private String name;
    private String sex;
    private int score;

    public User(){}
    public User(int id, String name, String sex, int score){
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.score = score;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", score=" + score +
                '}';
    }
}

测试类：

package One_Thirty;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Test {

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"榛果","男",100));
        list.add(new User(2,"张三","男",90));
        list.add(new User(3,"大倩","女",80));
        list.add(new User(4,"大力","男",40));
        list.add(new User(5,"刻晴","女",60));
        list.add(new User(6,"松本","男",50));

        //filter()方法用于过滤，collect()方法用于将过滤后得到的流转换为List集合
        List<User> collect = list.stream().filter(user -> user.getScore() > 60)
                .collect(Collectors.toList());
        //遍历
        collect.forEach(System.out::println);

        //也可以将两个合并
        list.stream().filter(user -> user.getScore() > 60).forEach(user -> System.out.println(user));

        //filter的contains方法，包含，.count()获取数量  输出结果 2  //distinct()，去重
        long count = list.stream().filter(user -> user.getName().contains("大")).count();
        System.out.println(count);

        // map函数的作用就是针对管道流中的每一个数据元素进行转换操作
        List<User> collect1 = list.stream().map(user -> {
            user.setId(user.getId() + 10);
            return user;
        }).collect(Collectors.toList());

        collect1.forEach(System.out::println);


        //由于map的参数e就是返回值，所以可以用peek函数。
        // peek函数是一种特殊的map函数，当函数没有返回值或者参数就是返回值的时候可以使用peek函数。
        list.stream().peek(user -> {
            user.setScore(user.getScore()+1);
        }).forEach(user -> System.out.println(user));
        
        

    }


}

flatMap
map可以对管道流中的数据进行转换操作，但是如果管道中还有管道无法处理。例如：将“hello”，“world”两个字符串组成的集合，元素的每一个字母打印出来。如果不用Stream，常规方法写2层for循环,第一层遍历字符串，并且将字符串拆分成char数组，第二层for循环遍历char数组。而如果用map的话，它只能针对一维数组进行操作，数组里面还有数组，管道里面还有管道，它是处理不了每一个元素的。此时用flatMap

List<String> words = Arrays.asList("hello", "word");
        words.stream()
                .flatMap(w -> Arrays.stream(w.split(""))) // [h,e,l,l,o,w,o,r,l,d]
                .forEach(System.out::println);