Java8新特性-Stream流的一些常用方法

Stream 相关知识点

1.Stream 不会存储元素
2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
4. Stream 执行流程
    1. Stream 的实例化
    2. 一系列的中间操作(过滤，映射...)
    3. 终止操作
5. 说明：
    1. 一个中间操作链，对数据源的数据进行处理
    2. 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

1. 先创建一个集合，后面会根据它来演示。

class UserData {
    public static List<User> getUser() {
        ArrayList<User> list = new ArrayList<>();
        list.add(new User("ming01", 1));
        list.add(new User("ming02", 2));
        list.add(new User("ming03", 3));
        list.add(new User("ming04", 4));
        list.add(new User("ming05", 5));
        return list;
    }
}


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

    public User() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

2. 创建 Stream 流的常见方法

1. 通过集合方式

	List<User> user = UserData.getUser();
	Stream<User> stream = user.stream();

2. 通过数组

	User u1 = new User();
	User u2 = new User();
	User[] users = {u1, u2};
	Stream<User> stream = Arrays.stream(users);

3. 中间操作方法–筛选与切片

List<User> users = UserData.getUser();
// 1. filter(Predicate) 接收Lambda,从流中排除某些元素 筛选出 id == 2 的 User
users.stream().filter(user -> user.getId() == 2)
        .forEach(System.out::println);
// 2. limit(n) 阶段流，使其元素不超过给定数量
users.stream()
        .filter(user -> user.getId() > 2)
        .limit(2)
        .forEach(System.out::println);
// 3. skip(n) 跳过元素，返回一个扔掉了前 n 个元素的流。若流中不足 n 个，则返回一个空流。与limit(n)互补
users.stream()
        .filter(user -> user.getId() > 2)
        .skip(2)
        .forEach(System.out::println);

4. 中间操作方法–映射

/*
   map(Function f) 接受一个函数作为参数，
   将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，
    并将其映射成一个新的元素。
 */
List<User> users = UserData.getUser();
users.stream()
        .map(User::getName)
        .filter(name -> name.lastIndexOf("5") == 5)
        .forEach(System.out::println);

5. 中间操作方法–排序

	List<Integer> list = Arrays.asList(12, 52, 14, 74, 96, 5, 8, 4);
	// 1. sorted() 自然排序
	list.stream().sorted().forEach(System.out::println);
	// 2. 自定义排序
	List<User> users = UserData.getUser();
	users.stream()
	            // 加个 - 号可以让它倒序排序
	        .sorted(Comparator.comparingInt(user -> -user.getId()))
	        .forEach(System.out::println);

6. 终止操作方法–归约

	// 1. reduce(T identity, BinaryOperator)  可以将流中元素反复结合起来，得到一个值，返回T
	List<User> users = UserData.getUser();
	Integer sum = users.stream().map(User::getId).reduce(0, Integer::sum);
	System.out.println(sum);

7. 终止操作方法–收集

	// collect(Collector c)  将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
	List<User> users = UserData.getUser();
	List<Integer> collect = users.stream()
	        .map(User::getId)
	        .collect(Collectors.toList());
	collect.forEach(System.out::println);

8. 终止操作方法–匹配与查找

List<User> users = UserData.getUser();
// 1. allMatch(Predicate p)——检查是否匹配所有元素。
boolean allMatch = users.stream().allMatch(user -> user.getId() > 3);
// 2. anyMatch(Predicate p)——检查是否至少匹配一个元素。
boolean allMatch2 = users.stream().anyMatch(user -> user.getId() > 3);
// 3. noneMatch(Predicate p)——检查是否没有匹配的元素。练习:是否存在员工姓"雷”
boolean noneMatch = users.stream().noneMatch(user -> user.getName().startsWith("ming"));
// 4. findFirst———返回第一个元素
Optional<User> first = users.stream().findFirst();
// 5. findAny——返回当前流中的任意元素
Optional<User> any = users.parallelStream().findAny();
// 6. count——返回流中元素的总个数
long count = users.stream().filter(user -> user.getId() > 3).count();
// 7. max(Comparator c)—返回流中最大值
Optional<Integer> max1 = users.stream().map(User::getId).max(Integer::compare);
// 8. min(Comparator c)——返回流中最小值
Optional<User> min = users.stream().min(Comparator.comparingDouble(User::getId));
// 9. forEach(Consumer c)——内部迭代
users.stream().forEach(System.out::println);