Java——lambda表达式和StreamAPI

标签：Java stream void System println StreamAPI lambda public out

一、lambda

1. lambda表达式

1.1 Lambda表达式的使用举例:

• (o1,02)->Integer.compare(o1,o2);

1.2 Lambda表达式的格式举例:

• Lambda形参列表->lambda

1.3 Lambda表达式的格式

lambda操作符或箭头操作符

• 的左边:lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
• 的右边:lambda体，对应着接口的实现类要重写的方法的方法体。

1.4 Lambda表达式的本质

• 一方面，lambda表达式作为接口的实现类的对象。--->"万事万物皆对象
• 另一方面，lambda表达式是一个匿名函数。

lambda使用格式实例

    //lambda表达式的使用练习1
    //lambda需要两个或以上的参数时，多条执行语句，并有返回值时
    @Test
    public void test7(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

            }
        };
        int compare1 = com1.compare(21,35);
        System.out.println(compare1);

        System.out.println("**********下面为使用lambda表达式*********");

        Comparator<Integer> com2 = (o1,o2) ->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        int compare2 = com2.compare(12,32);
        System.out.println(compare1);
    }



    //lambda表达式的使用练习2
    //两个参数，一个返回值
    @Test
    public void test7(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare1 = com1.compare(21,35);
        System.out.println(compare1);

        System.out.println("**********下面为使用lambda表达式*********");
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);
        int compare2 = com2.compare(12,32);
        System.out.println(compare1);
    }

    //lambda表达式的使用练习3
    //无参，无返回值
    @Test
    public void test10(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("去北京喝豆汁");
            }
        };
        r1.run();
        System.out.println("**********下面为使用lambda表达式*********");

        Runnable r2 = () -> System.out.println("去四川吃火锅");
        r2.run();
    }

    //lambda表达式的使用练习4
    //只有一个参数
    @Test
    public void test11(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("好像在哪里见过？");

        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("我想在梦里遇见你！");

    }

1.5.函数式接口:
问题一：什么是函数式接口?为什么需要函数式接口?

• 如果接口中只声明有一个抽象方法，则此接口就称为函数式接口。
• 因为只有给函数式接口提供实现类的对象时，我们才可以使用lambda表达式:

问题二：api中函数式接口所在的包

• jdk8中声明的函数式接口都在java.util.function包下

问题三：4个基本的函数式接口

接口名称	称谓	参数类型	返回类型	用途
Consumer<T>	消费型接口	T	无	对类型为 T 的对象应用操作，包含方法: void accept(T t)
Supplier<T>	供给型接口	无	T	返回类型为 T 的对象，包含方法: T get()
Function<T, R>	函数型接口	T	R	对类型为 T 的对象应用操作，并返回结果，包含方法: R apply(T t)
Predicate<T>	判断型接口	T	boolean	确定类型为 T 的对象是否满足某约束，包含方法: boolean test(T t)

函数式接口的使用实例：

/*ConsumerConsumer<T> void accept(T t);*/
    //语法格式：lambda表达式使用时，只有一个参数，可以省略掉()
    @Test
    public void test11(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("好像在哪里见过？");

        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("我想在梦里遇见你！");

    }

    /*Supplier<T> T get();*/
    @Test
    public void test12(){
        //构造器引用
        Supplier<Person> sup1 = Person :: new;
        System.out.println(sup1.get());
    }


    /*Function<T, R> R apply(T t)*/
    @Test
    public void test13(){
        Function<Integer,Person> fun1 = Person::new;
        System.out.println(fun1.apply(14));
    }

    /*BiFunction<T, U, R>  R apply(T t, U u)*/
    @Test
    public void test14(){
        BiFunction<String, Integer, Person> bif = Person::new;
        System.out.println(bif.apply("Tom", 18));
    }

1.6 语法规则总结;

• ->的左边:lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略
• ->的右边:lambda体，对应着重写的方法的方法体。如果方法体中只有一行执行语句，则一对{可以省略，若有return关键字，则必须一并省略。

2. 方法引用

2.1 方法的格式：

• Integer::compare

2.2 方法引用的埋解

• 方法引用，可以看做是基于lambda表达式的进一步刻画
• 当需要提供一个函数式接口的实例时，我们可以使用lambda表达式提供此实例。

>当满足一定的条件的情况下，我们还可以使用方法引用或构造器引用替换lambda表达式

2.3 方法引用的本质:

• 方法引用作为了函数式接口的实例。--->“万事万物皆对象"

2.4 格式:

• 类(或对象)::方法名

2.5.具体使用情况

情况1: 对象::实例方法

• 要求:函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的形参列表和返回值类都相同
• 此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意:此方法b是非静态的方法，需要对象调用

代码实例

/*情况一：对象::实例方法
    * Consumer中的void accept(T t)
    * PrintStream中的void println(T t)
    * */
    @Test
    public void test1(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        con.accept("喜羊羊与灰太狼");

        //lambda表达式
        Consumer<String> con1 = s->System.out.println(s);
        con1.accept("美羊羊与沸羊羊");

        //方法引用
        Consumer<String> con2 = System.out::println;
        con2.accept("懒洋洋的睡一觉");
    }

    /*Supplier中的get()方法
    * Employee中的String getName()
    * */
    @Test
    public void test2(){
        Employee emp = new Employee(1002,"马云",2, 9876.12);
        Supplier<String> sup1 = new Supplier<String>() {
            @Override
            public String get() {
                return emp.getName();
            }
        };

        System.out.println(sup1.get());

        //lambda方法
        Supplier<String> sup2 = ()-> emp.getName();
        System.out.println(sup2.get());

        //方法引用
        Supplier<String> sup3 = emp::getName;
        System.out.println(sup3.get());

    }

情况2: 类::静态方法

要求:

• 函数式接口中的抽象方法a与其内部实现时调用的类的某个静态方法b的形参列表和返回值类型都相同(或一致)，此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意:此方法b是静态的方法，需要类调用。

代码实例

//情况二：类::静态方法
    /*
    * Comparator中的int compare(T t,T t)
    * Integer中的int compare(T t,T t)
    * */
    @Test
    public void test3(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(com1.compare(12, 21));

        //lambda表达式
        Comparator<Integer> com2 = (o1 ,o2)->Integer.compare(o1,o2);
        System.out.println(com2.compare(21, 22));

        //方法引用
        Comparator<Integer> com3 = Integer::compare;
        System.out.println(com3.compare(44, 43));
    }

    /*
     * Function中的apply(T t)
     * Math中的long round(Double d)
     * */
    @Test
    public void test4(){
        Function<Double,Long> fun1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);//四舍五入
            }
        };
        System.out.println(fun1.apply(1.4));

        Function<Double,Long> fun2 = aDouble -> Math.round(aDouble);
        System.out.println(fun2.apply(1.6));

        Function<Double,Long> fun3 = Math::round;
        System.out.println(fun3.apply(2.1));
    }

情况3: 类::实例方法

要求:

• 函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的返回值类型相同。同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a的第1个参数作为方法b的调用者，且抽象方法a的后n-1个参数与方法b的n-1个参数的类型相同(或一致)。则可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用

注意:此方法b是非静态的方法，需要对象调用。但是形式上，写出对象a所属的类

代码实例

    //情况三：类::实例方法(难)
    /*
    * Comparator的int compare(T t,T t)
    * String中的int t1.compare(t2)
    *  */
    @Test
    public void test5(){
        Comparator<String> com1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };



        //方法引用
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abb","abb"));
    }

    /*
    * BiPredicate中的boolean test(T t1,T t2)
    * String中的boolean t1.equals(t2)
    * */
    @Test
    public void test6(){
        BiPredicate<String,String> bip = new BiPredicate<String, String>() {
            @Override
            public boolean test(String s1, String s2) {
                return s1.equals(s2);
            }
        };
        System.out.println(bip.test("10001", "10001"));

        //lambda表达式
        BiPredicate<String,String> bip1 = (s1,s2)->s1.equals(s2);
        System.out.println(bip.test("103", "1031"));

        //方法引用
        BiPredicate<String,String> bip2 = String::equals;
        System.out.println(bip.test("101", "10"));
    }

    /*
    * Function中的R apply(T t)
    * Employee中的string getName();
    * */
    @Test
    public void test7(){
        Employee emp = new Employee(1003,"刘强东",33,3000.82);

        Function<Employee,String> fun1 = new Function<Employee, String>() {
            @Override
            public String apply(Employee employee) {
                return emp.getName();
            }
        };
        System.out.println(fun1.apply(emp));

        //方法引用
        Function<Employee,String> fun2 = Employee::getName;
        System.out.println(fun2.apply(emp));
    }
}

3. 构造器引用

3.1 格式

• 类名:: new

3.2 说明

• 调用了类名对应的类中的某一个确定的构造器
• 具体调用的是类中的哪一个构造器呢?取决于函数式接口的抽象方法的形参列表!

3.3 代码示例

    /*Supplier<T> T get();*/
    @Test
    public void test12(){
        //构造器引用
        Supplier<Person> sup1 = Person :: new;
        System.out.println(sup1.get());
    }


    /*Function<T, R> R apply(T t)*/
    @Test
    public void test13(){
        Function<Integer,Person> fun1 = Person::new;
        System.out.println(fun1.apply(14));
    }

    /*BiFunction<T, U, R>  R apply(T t, U u)*/
    @Test
    public void test14(){
        BiFunction<String, Integer, Person> bif = Person::new;
        System.out.println(bif.apply("Tom", 18));
        //调用的是参数Integer和String类型，所以出来的是名字和年龄
    }

4. 数组引用

格式: 数组名[]::new

代码示例

//  数组引用
    @Test
    public void test15(){
        Function<Integer, Person[]> fun2 = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer length) {
                return new Person[length];
            }
        };
        System.out.println(fun2.apply(13).length);

        Function<Integer,Person[]> fun1 = Person[] :: new;
        System.out.println(fun1.apply(14).length);//数组的长度等于14
    }

二、StreamAPI

前言：

问题 ：什么是Stream？
Stream 是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。
Stream 和 Collection 集合的区别: Collection 是一种静态的内存数据结构，讲的是数据，而 stream 是有关计算，讲的是计算。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过 CPU 实现计算。

1.Stream API vs 集合框架

• Stream API 关注的是多个数据的计算(排序、查找、过滤、映射、遍历等)，面向CPU的。
• 集合关注的数据的存储，面向内存的。

即 ：Stream API 之于集合，类似于SOL之于数据表的查询。

2.使用说明

• Stream 自己不会存储元素。
• Stream不会改变源对象。相反，他们会返回一个持有结果的新stream。
• Stream, 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。
• Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

3.Stream 执行流程

Stream的操作三个步骤
1.创建 stream

• 一个数据源(如:集合、数组)，获取一个流

2.中间操作

• 每次处理都会返回一个持有结果的新stream，即中间操作的方法返回值仍然是stream类型的对象。因此中间操作可以是个 操作链 ，可对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。

3.终止操作

• 终止操作的方法返回值类型就不再是stream了，因此一旦执行终止操作，就结束整个stream操作了。一旦执行终止操作，就执行中间操作链，最终产生结果并结束stream。

图示：

3.1 Stream的实例化

1.三种实例化的方式

• 方式一：通过集合创建Stream实例
• 方式二：通过数组创建Stream实例
• 方式三：通过Stream.of()方式创建Stream实例

2.实例化代码实现

package data;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamAPiTest {
    //创建Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
        //返回一个顺序流
        Stream<Employee> stream = list.stream();

        //返回一个并行流
        Stream<Employee> stream1 = list.parallelStream();

        System.out.println(stream);
        System.out.println(stream1);
    }

    //创建Stream方式二：使用数组
    @Test
    public void test2(){
        //调用Arrays类的static <T>  Stream <T> Stream(T[] array): 返回一个流
        Integer[] arr = new Integer[] {1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(arr);

        int[] arr1 = new int[]{1,2,3,4,5};
        IntStream stream1 = Arrays.stream(arr1);
    }


    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<String> stream = Stream.of("AA","BB","CC","DD","EE");
    }
}

3.2 中间操作

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)	产生一个新流，其中按提供的比较器顺序排序。

4.中间操作代码实现

//中间操作
    //筛选与切片
    @Test
    public void test4(){
        //filter(Predicate p)，接收lambda方法---移除某些元素
        //集合实例化
        List<Employee> list = EmployeeData.getEmployees();

        //通过集合创建Stream的实例
        Stream<Employee> stream = list.stream();

        //查询员工表中薪资大于7000的员工的信息
        stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out::println);

        System.out.println("************************");
        //由于在上面Stream已经实行了终止操作，所以不可以在调用其他方法的终止操作
        //limit--截断流，使其元素不超过指定数量
        list.stream().filter(emp->emp.getSalary() > 7000).limit(2).forEach(System.out::println);

        //skip--跳过流，跳过前n个元素
        list.stream().skip(4).forEach(System.out::println);

    }
    
    
    //映射
    @Test
    public void test5(){
        //map(Function f)接收一个函数作为参数，该函数应用于每个元素，并映射成一个新的元素。
        //转换为大写   toUpperCase() 将字符串转换为大写
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        list.stream().map(String::toUpperCase).forEach(System.out::println);

        //获取姓名长度大于3的员工的姓名
        List<Employee> employees = EmployeeData.getEmployees();
        //先过滤后映射
        employees.stream().filter(emp->emp.getName().length() > 3).map(Employee::getName).forEach(System.out::println);
        //先映射后过滤
        employees.stream().map(Employee::getName).filter(name->name.length()>3).forEach(System.out::println);
    }
    
    
    //排序
    @Test
    public void test6(){
        //sorted()--自然排序
        Integer[] arr = new Integer[]{12,34,65,23,1,23,4,45};
        String[] arr1 = new String[]{"SS","EE","CC","BB","AA"};

        //使用数组创建Stream实例
        Arrays.stream(arr).sorted().forEach(System.out::println);

        //原本的数组并没有升序，而调整
        //Stream不会改变原对象
        System.out.println(Arrays.toString(arr));

        //sorted(comparator c)--定制排序
        Arrays.stream(arr1).sorted(String::compareTo).forEach(System.out::println);
    }

3.3 终止操作

1.匹配与查找

方法	描述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配任何元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素的总数
max(Comparator c)	返回流中元素的最大值
min(Comparator c)	返回流中元素的最小值
forEach(Consumer c)	对流中的每个元素执行给定的操作（内部迭代）

2.归约

方法	描述
reduce(T identity, BinaryOperator b)	可将流中元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator b)	可将流中元素反复结合起来，得到一个值。返回 Optional<T>

3.收集

方法	描述
collect(Collector c)	将流转换为其他形式。接收一个 Collector 接口的实现，用于给Stream中的元素汇总的方法

4.终止操作代码实现

//终止操作
    //匹配与查找
    @Test
    public void test7(){
        //allMatch检查是否匹配所有元素
        //是否所有员工都大于20岁
        List<Employee> list = EmployeeData.getEmployees();
        System.out.println(list.stream().allMatch(emp -> emp.getAge() > 20));

        //anyMatch检查是否至少一个元素满足要求
        System.out.println(list.stream().anyMatch(emp -> emp.getSalary() > 9600));

        //findFirst返回第一个元素
        System.out.println(list.stream().findFirst().get());

        //findAny返回任意一个元素
        System.out.println(list.stream().findAny().get());

        //count 返回流中元素的总数
        System.out.println(list.stream().filter(emp -> emp.getSalary() > 7000).count());

        //max(Comparator c) 返回流中最大值
        System.out.println(list.stream().max((a1, a2) -> Integer.compare(a1.getAge() , a2.getAge())));

        //min(Comparator c) 返回流中最大值
        System.out.println(list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

        //forEach(Consumer c)，遍历
        list.stream().forEach(System.out::println);
    }


    //归约
    @Test
    public void test8(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        //reduce(T identity, BinaryOperator b)
        //可将流中元素反复结合起来，得到一个值。返回T
        //操作;计算1-10的和
        System.out.println(list.stream().reduce(0, (s1, s2) -> s1 + s2));
        //前面的0或者10，相当于起始值
        System.out.println(list.stream().reduce(5, (s1, s2) -> s1 + s2));

        System.out.println(list.stream().reduce(15, Integer::sum));



        //reduce(BinaryOperator b)
        //可将流中元素反复结合起来，得到一个值。返回Optional<T>
        //操作：计算公司所有员工工资的总额

        List<Employee> list1 = EmployeeData.getEmployees();
        //先映射后计算
        list1.stream().map(emp->emp.getSalary()).reduce((s1,s2)->Double.sum(s1,s2));
        list1.stream().map(emp->emp.getSalary()).reduce(Double::sum);

    }

    //收集
    @Test
    public void test9(){
        /*collect(Collector c)
        将流转换为其他形式。接收一个Collector接口的实现
        用于给Stream中的元素汇总的方法*/
        //题目1：查找工资大于6000的员工，结果返回set或list
        List<Employee> list = EmployeeData.getEmployees();
        List<Employee> list1 = list.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toList());
        Set<Employee> list2 = list.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toSet());

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

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

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

        //题目2：按照员工的年龄排序，返回一个list
        //升
        List<Employee> list3 = list.stream().sorted((e1,e2)->e1.getAge()-e2.getAge()).collect(Collectors.toList());
        list3.forEach(System.out::println);

        System.out.println();

        //降
        List<Employee> list4 = list.stream().sorted((e1,e2)-> -(e1.getAge()-e2.getAge())).collect(Collectors.toList());
        list4.forEach(System.out::println);

    }

标签：Java,stream,void,System,println,StreamAPI,lambda,public,out
From： https://blog.csdn.net/m0_72047169/article/details/143353125