java Stream流 常用方法

Stream分为三部分 ：数据源 数据处理 返回结果 (需理解)
max min reduce sorted map filter forEach limit skip distinct
anyMatch、allMatch、noneMatch、findAny、findFirst 等等方法

User对象的创建

public class User {

    private String name;
    private Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

测试代码

import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class test {
    public static void main(String[] args) {
        //创建集合(数据源)
        List<User> list = Arrays.asList(
                new User("小明", 21),
                new User("小红", 20),
                new User("小张", 20)
        );

        //正常来说想要经过某些条件筛选出一些符合条件的对象 需要 (数据处理)
        ArrayList<User> result = new ArrayList<>();
        for (User user : list) {
            if (user.getAge() < 21) {
                result.add(user);
            }
        }
        System.out.println(result);

        System.out.println("============================================");

        //但如果使用Stream的filter就可以简化这个过程
        //filter就是条件过滤器
        Predicate<User> predicate1 = user -> user.getAge() < 21;
        Predicate<User> predicate2 = user -> user.getAge() >= 20;

        //当前filter里面的条件可以直接写加入
        //List<User> userList = list.stream().filter( user -> user.getAge() < 21).collect(Collectors.toList());
        //要做与或的过滤 可以通过设置过个filter 也可以通过predicate的and或or方法来进行

        //List<User> userList = list.stream().filter(predicate1).filter(predicate2).collect(Collectors.toList());
        //.collect就是 返回结果的一种 下面还有
        List<User> userList = list.stream().filter(predicate1.and(predicate2)).collect(Collectors.toList());
        System.out.println(userList);

        
        System.out.println("");
        List<Integer> list1 = Arrays.asList(1, 6, 3, 2, 4, 5);
        //求最大值
        if (list1.stream().max(Integer::compareTo).isPresent()) { //判断是否有值
            System.out.println(list1.stream().max(Integer::compareTo).get());
        }
        //求最小值
        if (list1.stream().min(Integer::compareTo).isPresent()) { //判断是否有值
            System.out.println(list1.stream().min(Integer::compareTo).get());
        }
        //求长度
        System.out.println(list1.stream().count());
        //排序
        System.out.println(list1.stream().sorted().collect(Collectors.toList()));//升序
        System.out.println(list1.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()));//逆序
        //如果要复杂的排序 则需要自己定义比较器
//        list1.stream().sorted(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return 0;
//            }
//        });
//        List<Integer> collect = list1.stream().sorted((o1, o2) -> o1 - o2).collect(Collectors.toList());
        //所有值在原本的基础上做修改
        list1.stream().map(num -> num + 10).forEach(item -> System.out.print(item + ","));
//        这种forEach的用法相当于item -> System.out.println(item) 并不能够修改
//        list1.stream().map(num -> num + 10).forEach(System.out::println);
        System.out.println();
        System.out.println(list1.stream().reduce((a, b) -> a + b).get());

        //限制输出数量
        System.out.println(list1.stream().limit(2).collect(Collectors.toList()));

        
        int[] array = new int[]{1, 3, 2, 4, 5, 1, 3};
        System.out.println(Arrays.stream(array).sum());//数组求和
        List<Integer> collect = Arrays.stream(array).boxed().collect(Collectors.toList());//数组变集合
        System.out.println(collect);
        List<Integer> list2 = Arrays.stream(array).boxed().distinct().collect(Collectors.toList());//去重
        list2.forEach(item -> System.out.print(item + " "));
        System.out.println();
        //跳过n个元素
        List<Integer> collect1 = Arrays.stream(array).boxed().skip(2).collect(Collectors.toList());
        collect1.forEach(item -> System.out.print(item + " "));

        System.out.println("//");
        System.out.println(Arrays.stream(array).boxed().anyMatch(a -> a < 2));//anyMatch是只要匹配一个条件就算成功 返回true
        System.out.println(Arrays.stream(array).boxed().allMatch(a -> a > 0));//allMatch是必须所有元素都满足条件才 返回true
        System.out.println(Arrays.stream(array).boxed().noneMatch(a -> a == -1));//noneMatch是没有一个满足条件  返回true
        System.out.println(Arrays.stream(array).boxed().findFirst().get());//获取第一个元素
        System.out.println(Arrays.stream(array).boxed().findAny().get());//获取随机一个元素  但由于stream的串行 所以永远只能获取第一个
        if (Arrays.stream(array).parallel().findAny().isPresent()) {
            System.out.println(Arrays.stream(array).parallel().findAny().getAsInt());//这个才是真正的随机获取一个元素
        }
    }
}