Java基础知识 34（JDK1.8之Stream流）

JDK1.8之Stream流

使用Stream流分为3个阶段：

（1）获取一个Stream流，来关联一个容器。

（2）进行中间环节的操作，来得到一个持有新结果的流

（3）进行终止操作，得到我们的结果，但是并不会对原有的容器有任何改变。

获取流->过滤->终止操作

public class Mytest {
    public static void main(String[] args) {
        //1.想要有一个容器
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        //2.获取一个流
        Stream<Employee> stream = list.stream();
        //3.进行中间操作
        Stream<Employee> employeeStream = stream.filter(employee -> employee.getSalary() > 6000);
        //4.终止操作
        employeeStream.forEach(System.out::println);
        System.out.println("---------------------------");
        //我们采用链式编程
        list.stream().filter(employee -> employee.getSalary() > 6000).forEach(System.out::println);
        System.out.println("---------------------------");
        //过滤出来姓赵的员工
        list.stream().filter(employee -> employee.getName().startsWith("赵")).forEach(System.out::println);
    }
}

获取Stream流的几种方式

//获取Stream流的几种方式
//方式1：要有一个容器
List<Integer> list = Arrays.asList(20, 30, 40, 50, 60);
//通过集合中的方法Stream()来获取一个Stream流
Stream<Integer> stream = list.stream();
//方式2：获取一个Stream流
Integer[] arr={20,30,50};
Stream<Integer> stream1 = Arrays.stream(arr);
//方式3：通过Stream这个类中的静态方法of()
Stream<Integer> stream2 = Stream.of(20, 30, 50, 60, 90);
Stream<List<Integer>> list1 = Stream.of(list);
Stream<Integer> arr1 = Stream.of(arr);
System.out.println("--------------------");
//方式4：获取无限流
Stream<Integer> iterate = Stream.iterate(1, num -> num + 1);

获取流->过滤->去重->终止操作

public class Mytest2 {
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        //获取流
        Stream<Employee> stream = list.stream();
        //对流进行过滤
        Stream<Employee> employeeStream = stream.filter(employee -> employee.getSalary() > 6000);
        //对元素进行去重
        Stream<Employee> distinct = employeeStream.distinct();
        //对流过滤完进行终止
        distinct.forEach(System.out::println);
        System.out.println("-----------------------------");
        //以上步骤，我们进行链式编程
        list.stream().filter(employee -> employee.getSalary()>6000).distinct().forEach(System.out::println);
    }
}

获取流->过滤->限制数量->终止操作

public class Mytest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(10, 20, 30, 40, 50);
        Stream<Integer> stream = list.stream();
        Stream<Integer> integerStream = stream.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 10;
            }
        });
        Stream<Integer> limit = integerStream.limit(2);
        limit.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
        System.out.println("------------------");
        //设置一个容器
        List<Employee> list1 = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        //获取年龄大于20岁的员工
        list1.stream().filter(employee -> employee.getAge()>20).distinct().forEach(System.out::println);
    }
}

获取流->过滤->skip跳跃->终止操作

public class Mytest2 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(10, 20, 30, 40, 50);
        Stream<Integer> stream = list.stream();
        Stream<Integer> integerStream = stream.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 10;
            }
        });
        Stream<Integer> skip = integerStream.skip(2);
        skip.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
        //注意：终止操作不执行，中间环节就不执行，体现的是一种延迟加载的思想，你想要用的时候，我再去操作。
        System.out.println("------------------------");
        List<Integer> list1 = Arrays.asList(10, 20, 30, 40, 50);
        Stream<Integer> stream1 = list1.stream();
        Stream<Integer> integerStream1 = stream1.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                System.out.println("中间环节执行了");
                return integer > 10;
            }
        });
        //遍历：终止操作
        integerStream1.forEach(integer -> System.out.println(integer));
    }
}

map(Function f)接收到一个函数作为参数，该函数会被应用到每个元素之上，并将其映射为一个新元素

public class Mytest {
    public static void main(String[] args) {
        //map(Function f)接收到一个函数作为参数，该函数会被应用到每个元素之上，并将其映射成为一个新元素。
        //提前集合中的元素，应用到一个方法上
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        Stream<Employee> stream = list.stream();
        Stream<Object> objectStream = stream.map(new Function<Employee, Object>() {
            @Override
            public Object apply(Employee employee) {
                return employee.getName();
            }
        });
        objectStream.forEach(new Consumer<Object>() {
            @Override
            public void accept(Object obj) {
                System.out.println(obj);
            }
        });
        System.out.println("-------------------------");
        //以上步骤进行链式编程
        list.stream().map(employee -> employee.getName()).forEach(System.out::println);
    }
}

flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流.

public class Mytest3 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        //提取集合中的每一个元素，把这个字符串，截取成一个个字符，放到换一个集合中，在把这个集合转换成Stream流返回。
        //"aaa" --->'a' 'a' 'a' ---> ['a','a','a']--->流
        Stream<String> stream = list.stream();
        Stream<Stream<Character>> objectStream = stream.map(new Function<String, Stream<Character>>() {
            @Override
            public Stream<Character> apply(String s) {
                //System.out.println(s);
                // 提取集合中的每一个元素，把这个字符串，截取成一个个字符，放到一个集合中，在把这个集合转换成Stream流返回。
                //这个操作，没有现成方法可用，那我们自己就编写一个
                return getStreamChar(s);
            }
        });
        //终止操作 遍历每一个字符
        objectStream.forEach(new Consumer<Stream<Character>>() {
            @Override
            public void accept(Stream<Character> characterStream) {
                characterStream.forEach(character -> System.out.println(character));
            }
        });
        System.out.println("===================================");
        //flatMap(Function f)		接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流.
        //用flatMap 来做一下
        List<String> list2 = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        //提取集合中的每一个元素，把这个字符串，截取成一个个字符，放到换一个集合中，在把这个集合转换成Stream流返回。
        Stream<String> stream1 = list2.stream();
        Stream<Character> characterStream = stream1.flatMap(new Function<String, Stream<Character>>() {
            @Override
            public Stream<Character> apply(String s) {
                return getStreamChar(s);
            }
        });
        characterStream.forEach(character -> System.out.println(character));
    }
    private  static Stream<Character> getStreamChar(String s) {
        //"aaa"
        ArrayList<Character> arrayList = new ArrayList<>();
        for (char c : s.toCharArray()) {
            arrayList.add(c);
        }
        Stream<Character> stream = arrayList.stream();
        return stream;
    }
}

mapToInt：返回一个包含应用给定的功能，该流的元素的结果是InputStream

public class Mytest4 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(200, 30, 20);
        Stream<Integer> stream = list.stream();
        //mapToInt:返回一个包含应用给定的功能，该流的元素的结果是InputStream
        //求一个数的平方
        IntStream intStream = stream.mapToInt(value -> (int) Math.pow(value,2));
        intStream.forEach(value -> System.out.println(value));
    }
}

获取流->比较器排序->终止操作

public class Mytest5 {
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        Stream<Employee> stream = list.stream();
        //按照年龄大小进行排序
        //采用的是比较器排序法，自然排序法要求元素实现一个Comparable接口
        Stream<Employee> sorted = stream.sorted(new Comparator<Employee>() {
            @Override
            public int compare(Employee e1, Employee e2) {
                return e1.getAge() - e2.getAge();
            }
        });
        sorted.forEach(new Consumer<Employee>() {
            @Override
            public void accept(Employee employee) {
                System.out.println(employee);
            }
        });
        System.out.println("---------------------");
        //采用链式编程重写以上步骤
        list.stream().sorted((e1,e2)->e1.getAge()-e2.getAge()).forEach(System.out::println);
    }
}

allMatch(Predicate p) 检查是否匹配所有元素 比如判断 所有员工的年龄都是17岁 如果有一个不是, 就返回false

public class Mytest {
    public static void main(String[] args) {
        //终止操作，当我们执行完了中间环节，就想要执行终止操作，来得到中间环节流持有的结果
        //终止操作中，最常用的一个操作，就是遍历，forEach();
        //有的时候，并不是只想打印看，我们是想要获取中间环节操作完之后的结果。
        // allMatch(Predicate p) 检查是否匹配所有元素 比如判断 所有员工的年龄都是17岁 如果有一个不是, 就返回false
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        Stream<Employee> stream = list.stream();
        //终止操作
        boolean b = stream.allMatch(new Predicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getAge() == 17;
            }
        });
        System.out.println(b);
        System.out.println("====================================");
        //中间操作。把所有年龄提取出出来
        Stream<Employee> stream2 = list.stream();
        Stream<Integer> integerStream = stream2.map(new Function<Employee, Integer>() {
            @Override
            public Integer apply(Employee employee) {
                return employee.getAge();
            }
        });
        //终止操作做判断
        boolean b1 = integerStream.allMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer == 17;
            }
        });
        System.out.println(b1);
    }
}

anyMatch(Predicate p)：检查是否至少匹配一个元素，比如说，在判断是否有姓王的员工，如果至少有一个返回true

public class Mytest2 {
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        Stream<Employee> stream = list.stream();
        //anyMatch(Predicate p) 检查是否至少匹配一个元素，比如说，在判断是否有姓王的员工，如果至少有一个就返回true
        boolean b = stream.anyMatch(new Predicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() > 7000;
            }
        });
        System.out.println(b);
    }
}

noneMatch()：employee.getSalary()<3000；每个员工的工资如果高于3000，就返回true，如果有一个低于3000，都返回false。

public class Mytest3 {
    public static void main(String[] args) {
        //noneMatch()   employee.getSalary() < 3000;每个员工的工资如果高于3000，就返回true，如果有一个低于3000，都返回false.
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        Stream<Employee> stream = list.stream();
        boolean b = stream.noneMatch(new Predicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() < 3000;
            }
        });
        System.out.println(b);
        System.out.println("-----------------------");
        boolean b1 = list.stream().noneMatch(employee -> employee.getSalary() < 3000);
        System.out.println(b1);
    }
}

findFirst() ：返回第一个元素，比如获取最高工资的人，或者获取最高工资的值

public class Mytest {
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        //findFirst() 返回第一个元素，比如获取工资最高的人，或者获取工资最高的值
        Optional<Employee> first = list.stream().sorted((e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary())).findFirst();
        Employee employee = first.get();
        System.out.println(employee);
        System.out.println("-----------------------");
        //获取工资最高的值
        Optional<Double> first1 = list.stream().map(e -> e.getSalary()).sorted((a, b) -> (int) (b-a)).findFirst();
        Double aDouble = first1.get();
        System.out.println(aDouble);
    }
}

findAny() ：返回当前流中的任意元素 list,Stream—串行流 list.parallelStream—并行流

public class Mytest2 {
    public static void main(String[] args) {
        //findAny() 返回当前流中的任意元素，比如随便获取一个姓王的员工
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(105, "田七", 38, 0.55)
        );
        //int size = list.size();
        //串行流  list.stream
        //并行流  list.parallelStream()
        Optional<Employee> any = list.parallelStream().filter(new Predicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getName().startsWith("王");
            }
        }).findAny();
        Employee employee = any.get();
        System.out.println(employee);
        System.out.println("--------------------------");
        long count = list.stream().distinct().count();
        System.out.println(count);
        System.out.println("--------------------------");
        Optional<Employee> min = list.stream().min(new Comparator<Employee>() {
            @Override
            public int compare(Employee e1, Employee e2) {
                return (int) (e1.getSalary() - e2.getSalary());
            }
        });
        Employee employee1 = min.get();
        System.out.println(employee1);
        System.out.println("---------------------------");
        Optional<Double> min1 = list.stream().map(employee2 -> employee2.getSalary()).min(new Comparator<Double>() {
            @Override
            public int compare(Double e1, Double e2) {
                return (int) (e1 - e2);
            }
        });
        Double aDouble = min1.get();
        System.out.println(aDouble);
    }
}

reduce(T iden,BinaryOperator p)：参数1是起始值，参数2是二元运算，可以将流中的元素反复结合起来，得到一个值，返回T，求集合中元素的累加集合。

public class Mytest3 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(20, 30, 50, 200);
        //reduce(T iden,BinaryOperator b) 参数1 是起始值，参数2 二元运算，
        // 可以将流中的元素反复结合起来，得到一个值，返回T，求集合中元素的累加集合
        Optional<Integer> reduce = list.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        });
        Integer integer = reduce.get();
        System.out.println(integer);
        System.out.println("---------------------");
        //参数1：你可以给一个起始值
        Integer reduce1 = list.stream().reduce(0, (a, b) -> a + b);
        System.out.println(reduce1);
        System.out.println("---------------------");
        List<Employee> list1 = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(101, "王三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "王六", 17, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 17, 7777.77),
                new Employee(105, "田七", 38, 0.55)
        );
        //求员工总工资
        Double reduce2 = list1.stream().map(employee -> employee.getSalary()).reduce(0.0, (a, b) -> a + b);
        System.out.println(reduce2);
    }
}