StreamAPI的应用及示例

示例代码

package com.debuggg.java.exer5;

import com.debuggg.java.exer4.Employee;
import com.debuggg.java.exer4.EmployeeData;
import org.junit.Test;

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

/**
 * 作者 ZYL
 * 功能描述 :
 * 1.Stream 关注的是对数据的运算，与CPU打交道
 *  集合关注的是数据的存储，与内存打交道
 * 2.
 * 1）Stream 自己不会存储元素
 * 2）Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
 * 3）Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
 *
 * 3.Stream 执行流程
 *  1）Stream的实例化
 *  2）一系列的中间操作（过滤，映射，。。。）
 *  3）终止操作
 * 4.说明：
 *  1）一个中间操作链，对数据源的数据进行处理
 *  2）一旦执行终止操作，就执行中间操作链，并产生结果，之后，不会再被使用
 *
 * 测试Strem的实例化
 * 日期 2020-03-01 18:32  
 * 参数 null
 * 返回值
 */
public class StreamAPITest {
    /**
     * 作者 ZYL
     * 功能描述 : 创建Stream方式一：通过集合
     * java8中的Collection接口被扩展，提供了两个获取流的方法
     *  1)default Stream<E> stream():返回一个顺序流
     *  2)default Stream<E> parallelStream():返回一个并行流
     *
     * 日期 2020-03-01 18:38
     * 参数
     * 返回值 void
     */
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
//        1)default Stream<E> stream():返回一个顺序流
        Stream<Employee> stream = employees.stream();
//        default Stream<E> parallelStream():返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }

    /**
     * 作者 ZYL
     * 功能描述 : 创建Stream方式二：通过数组
     * java8中的Arrays的静态方法stream()可以获取数组流：
     *  1）static <T> Stream<T> stream(T[] array):返回一个流
     *  重载形式，能够处理对应基本类型的数组：
     *  2）public static IntStream stream(int[] array)
     *  3）public static LongStream stream(long[] array)
     *  4）public static DoubleStream stream(double[] array)
     *
     * 日期 2020-03-01 18:43
     * 参数 
     * 返回值 void
     */
    @Test
    public void test2(){

        String[] strings = {"马化腾", "马云"};
        Stream<String> stream = Arrays.stream(strings);

        int[] ints = {1,2,3};
        IntStream stream1 = Arrays.stream(ints);
    }

    /**
     * 作者 ZYL
     * 功能描述 : 创建Stream方式三：通过Stream的of()
     * 可以调用Stream类静态方法of(),通过显示值创建一个流，它可以接受任意数量的参数
     * 1.public static<T> Stream<T> of(T... values):返回一个流
     * 日期 2020-03-01 19:06
     * 参数
     * 返回值 void
     */
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

    }

    /**
     * 作者 ZYL
     * 功能描述 : 创建Stream方式四：创建无限流
     * 可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流
     * 1）迭代
     * public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
     * 2）生成
     * public static<T> Stream<T> generate(Supplier<T> s)
     * 日期 2020-03-01 19:10
     * 参数
     * 返回值 void
     */
    @Test
    public void test4(){
        //遍历前十个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out :: println);

        //获取10个随机数并遍历处理啊
        Stream.generate(() -> Math.random()).limit(10).forEach((d) -> System.out.println(d));

    }





    /**
     * 作者 ZYL
     * 功能描述 : Stream的中间操作
     * 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，
     * 否则中间操作不会执行任何处理！而在终止操作时一次性全部处理，称为“惰性求值”
     * 1.筛选与切片方法：
     *  filter(Predicate p) 接收Lambda,从流中排除某些元素
     *  distinct() 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
     *  limit(long maxSize) 截断流，使其元素不超过给定水浪
     *  skip(long n) 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补
     *
     * 2.映射
     *  map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
     *  mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
     *  mapToInt(ToIntFunction f) 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
     *  mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
     *  flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     *
     * 3.排序
     *  sorted() 产生一个新流，其中按自然顺序排序
     *  sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
     *
     * 日期 2020-03-01 19:22
     * 参数 null
     * 返回值
     */

    /**
     * 作者 ZYL
     * 功能描述 : 筛选与切片
     * 日期 2020-03-01 23:36  
     * 参数 
     * 返回值 void
     */
    @Test
    public void test5(){
//     * 1.筛选与切片方法：
//     *
//     *  filter(Predicate p) 接收Lambda,从流中排除某些元素
        Stream<Employee> stream = EmployeeData.getEmployees().stream();
        //过滤工资大于7000的employee
//        stream.filter(e -> e.getSalary() > 7000).forEach(System.out :: println);
//     *  distinct() 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
//        stream.distinct().forEach(System.out::println);
//     *  limit(long maxSize) 截断流，使其元素不超过给定水浪
//        stream.limit(5).forEach(System.out::println);
//     *  skip(long n) 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补

        //跳过2个，去重，过滤工资大于6000，限制取1的写法
        stream.skip(2).distinct().filter(e -> e.getSalary() > 6000).limit(1).forEach(System.out::println);


    }

    /**
     * 作者 ZYL
     * 功能描述 :
     * * 2.映射
     *      *  map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
     *      *  mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
     *      *  mapToInt(ToIntFunction f) 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
     *      *  mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
     *      *  flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     * 日期 2020-03-01 23:54
     * 参数 null
     * 返回值
     */
    @Test
    public void test6(){
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Employee> stream = employees.stream();

        String[] strings = {"aa", "bb", "cc", "dd"};
        Stream<String> stream1 = Arrays.stream(strings);
        stream1.map(String::toUpperCase).forEach(System.out::println);
        //给每个员工涨工资5000
//        stream.map(e -> {
//            e.setSalary(e.getSalary() + 5000.0);
//            return e;
//        }).forEach(System.out::println);
//        *  map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
        //获取员工姓名长度大于3的
        employees.stream().map(Employee::getName).filter(e -> e.length() > 3).forEach(System.out::println);

        System.out.println();
        //获取工资的列表清单
        employees.stream().mapToDouble(e -> e.getSalary()).forEach(System.out::println);
//        *  mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream

        System.out.println();
        //获取年龄清单
        employees.stream().mapToInt(Employee::getAge).forEach(System.out::println);
//        *  mapToInt(ToIntFunction f) 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream

        //获取年龄清单，并且将年龄设置成Long型
        employees.stream().mapToLong(Employee::getAge).forEach(System.out::println);
//        *  mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream

//        *  flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        System.out.println();
        //将strings的字符拆散
        Arrays.stream(strings).flatMap(StreamAPITest::formString2Stream).forEach(System.out::println);
        //等价于
        System.out.println();
        Stream<Stream<Character>> streamStream = Arrays.stream(strings).map(StreamAPITest::formString2Stream);
        streamStream.forEach( s -> s.forEach(System.out::println));
    }

    public static Stream<Character> formString2Stream(String str){
        List<Character> list = new ArrayList<>();
        for (char c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    /**
     * 作者 ZYL
     * 3.排序
     *  sorted() 产生一个新流，其中按自然顺序排序
     *  sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
     * 日期 2020-03-02 0:05
     * 参数 null
     * 返回值
     */
    @Test
    public void test7(){
//             * 3.排序
//             *  sorted() 产生一个新流，其中按自然顺序排序
        List<Employee> employees = EmployeeData.getEmployees();
        //构造器中的比较方法，按照工资的升序排序
        employees.stream().sorted().forEach(System.out::println);

        System.out.println();
//             *  sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
        //按照工资从高到底排序
        employees.stream().sorted((o1,o2) -> -o1.getSalary().compareTo(o2.getSalary())).forEach(System.out::println);

    }



    /**
     * 作者 ZYL
     * 功能描述 : Strem的终止操作
     * 1.终端操作会从流的流水线生成结果，其结果可以时任何不是流的值，例如：List,Integer,甚至时void
     * 2.流进行了终止操作之后，不能再次使用
     *
     * 3.具体操作
     *  1）匹配与查找
     *      ①allMatch(Predicate p) 检查是否匹配所有元素
     *      ②anyMatch(Predicate p) 检查是否至少匹配一个元素
     *      ③noneMatch(Predicate p) 检查是否一个都没有匹配上
     *      ④findFirst() 返回第一个元素
     *      ⑤findAny() 返回当前流中的任意元素
     *      ⑥count() 返回流中的元素总数
     *      ⑦max(Comparator c) 返回流中的最大值
     *      ⑧min(Comparator c) 返回流中的最小值
     *      ⑨forEach(Consumer c)内部迭代（使用Collection接口需要用户取做迭代，成为外部迭代。相反
     *          Stream API使用内部迭代----它帮你把迭代做了）
     *  2）规约
     *      ①reduce(T iden,BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回T
     *      ②reduce(BinaryOperator b) 可以将流中元素反复结合起来得到一个值。返回Optional<T>
     *          备注：map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名
     *  3）收集
     *      ①collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
     *          Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
     *          另外：Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
     * 日期 2020-03-02 0:55
     * 参数 null
     * 返回值
     */

    /**
     * 作者 ZYL
     * 功能描述 : 匹配与查找i
     * 日期 2020-03-02 0:59  
     * 参数 null
     * 返回值 
     */
    @Test
    public void test8(){
//            *      ①allMatch(Predicate p) 检查是否匹配所有元素
        int[] ints = {1, 2, 3, -9, 20, -38, 100, 88};
        System.out.println(Arrays.stream(ints).allMatch(s -> s > 80));
        System.out.println();

//            *      ②anyMatch(Predicate p) 检查是否至少匹配一个元素
        System.out.println(Arrays.stream(ints).anyMatch(s -> s > 80));
        System.out.println();
//            *      ③noneMatch(Predicate p) 检查是否一个都没有匹配上
        System.out.println(Arrays.stream(ints).noneMatch(s -> s > 80));
        System.out.println();

//            *      ④findFirst() 返回第一个元素
        System.out.println(Arrays.stream(ints).findFirst());
        System.out.println();
//            *      ⑤findAny() 返回当前流中的任意元素
        System.out.println(Arrays.stream(ints).findAny());
        System.out.println();
//            *      ⑥count() 返回流中的元素总数
        System.out.println(Arrays.stream(ints).count());
        System.out.println();
//            *      ⑦max(Comparator c) 返回流中的最大值
        System.out.println(Arrays.stream(ints).max());
        System.out.println();
//            *      ⑧min(Comparator c) 返回流中的最小值
        System.out.println(Arrays.stream(ints).min());
        System.out.println();
//            *      ⑨forEach(Consumer c)内部迭代（使用Collection接口需要用户取做迭代，成为外部迭代。相反
        Arrays.stream(ints).forEach(System.out::println);
        System.out.println();
//            *          Stream API使用内部迭代----它帮你把迭代做了）
    }

    /**
     * 作者 ZYL
     * 功能描述 :
     *  2）规约
     *      ①reduce(T iden,BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回T
     *      ②reduce(BinaryOperator b) 可以将流中元素反复结合起来得到一个值。返回Optional<T>
     *       备注：map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名
     * 日期 2020-03-02 1:23
     * 参数 null
     * 返回值
     */
    @Test
    public void test9(){
        int[] ints = {1, 2, -3};
        OptionalInt reduce = Arrays.stream(ints).reduce((i1, i2) -> i1 * i2);
        System.out.println(reduce);
    }

    /**
     * 作者 ZYL
     * 功能描述 :
     *  3）收集
     *      ①collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
     *          Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
     *          另外：Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
     * 日期 2020-03-02 1:41
     * 参数 null
     * 返回值
     */
    @Test
    public void test10(){
        List<Integer> list = Arrays.asList(1, 2, 3, -9, 20, -38, 100, 88);
        Set<Integer> collect = list.stream().filter(i -> i > 0).collect(Collectors.toSet());
        list.stream().filter(i -> i > 0).collect(Collectors.toList());
        System.out.println(collect);
//                *  3）收集
//                *      ①collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
//                *          Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List,Set,Map）
//                *          另外：Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
    }
}

Employee代码

package com.debuggg.java.exer4;

import java.util.Objects;

public class Employee implements Comparable<Employee>{

    private Integer id;

    private String name;

    private Integer age;

    private Double salary;

    public Employee() {
    }

    public Employee(Integer id, String name, Integer age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public Employee(Integer id) {
        this.id = id;
    }
    public Employee(Integer id,String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

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

    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;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Objects.equals(id, employee.id) &&
                Objects.equals(name, employee.name) &&
                Objects.equals(age, employee.age) &&
                Objects.equals(salary, employee.salary);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, salary);
    }

    @Override
    public int compareTo(Employee o) {
        return this.salary.compareTo(o.getSalary());
    }
}

EmployeeData代码

package com.debuggg.java.exer4;

import java.util.ArrayList;
import java.util.List;

public class EmployeeData {

    public static List<Employee> getEmployees(){
        List<Employee> list = new ArrayList<>();

        list.add(new Employee(1001,"马化腾",34,6000.38));
        list.add(new Employee(1002,"马云",12,9876.12));
        list.add(new Employee(1003,"刘强东",33,3000.82));
        list.add(new Employee(1004,"雷军",26,7567.37));
        list.add(new Employee(1005,"李彦宏",65,5555.32));
        list.add(new Employee(1006,"比尔盖茨",42,9500.43));
        list.add(new Employee(1007,"任正非",26,4333.32));
        list.add(new Employee(1008,"扎克伯格",35,2500.32));
        list.add(new Employee(1008,"扎克伯格",35,2500.32));

        return list;
    }
}