lambda表达式

lambda表达式

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.*;

/**
 * @author 小邱
 * @version 0.0.1
 * @description LambdaTest
 * @since 2021/9/16 14:24
 */
public class LambdaTest {
    /*
        适用于只有一个抽象方法的接口
        lambda操作符：->
        操作符左边：形参列表（接口中的抽象方法形参列表）
        操作符右边：重写抽象方法的方法体
     */
    //lambda表达式: ->
    @Test
    public void test1() {
        //1、无参无返回值
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("r1");
            }
        };
        r1.run();

        //lambda表达式
        Runnable r2 = () -> System.out.println("r2");
        r2.run();

        //2、一个参数无返回值
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("consumer");
            }
        };

        //lambda表达式
        Consumer<String> consumer1 = (String s) -> System.out.println(s);
        consumer1.accept("consumer1");

        //3、类型推断（数据类型可省略）
        Consumer<String> consumer2 = (s) -> System.out.println(s);
        consumer2.accept("consumer2");

        //4、一个参数时括号可省
        Consumer<String> consumer3 = s -> System.out.println(s);
        consumer3.accept("consumer3");

        //5、两个以上参数，多条执行语句，有返回值
        Comparator<Integer> c1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(c1.compare(12, 34));

        //lambda表达式
        Comparator<Integer> c2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(c2.compare(23, 56));

        //6、方法体只有一条语句时，return 与大括号可省略
        Comparator<Integer> c3 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(c3.compare(12, 34));

        //lambda表达式
        Comparator<Integer> c4 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(c4.compare(23, 56));
    }

    /*
        方法引用: ::
        操作符左边：类或对象
        操作符右边：方法名

        接口中抽象方法的形参列表与返回值类型和方法引用的要一致
        对象::非静态方法
        类::静态方法


        类::实例方法

     */
    //方法引用: ::
    @Test
    public void test2() {
        //对象::非静态方法
        //Consumer 的 void accept(T t)
        //PrintStream 的 void println(T t)
        PrintStream ps = System.out;
        Consumer<String> consumer = ps::println;
        consumer.accept("consumer");

        Person person = new Person("tom", 23);
        Supplier<String> supplier = person::getName;
        System.out.println(supplier.get());

        //类::静态方法
        //Comparator的int compare(T t1,T t2)
        //Integer 的 int compare(T t1,T t2)
        Comparator<Integer> c1 = Integer::compare;
        System.out.println(c1.compare(12, 45));

        //类::实例方法
        //Comparator的int compare(T t1,T t2)
        //String的int t1.compareTo(t2)
        Comparator<String> comparator = String::compareTo;
        System.out.println(comparator.compare("abd", "ase"));

        //BiPredicate的boolean test(T t1,T t2)
        //String的boolean t1.equals(t2)
        BiPredicate<String, String> biPredicate = String::equals;
        System.out.println(biPredicate.test("qwe", "qwe"));


    }

    /*
        和方法引用类似，函数式接口的抽象方法形参列表和构造器的形参列表一致
        抽象方法的返回值类型即构造器所属类的类型
     */
    //构造器引用
    @Test
    public void test3() {
        //Supplier的T get()
        //Person的空参构造器 Person()
        Supplier<Person> supplier1 = new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person();
            }
        };
        System.out.println(supplier1.get());

        Supplier<Person> supplier2 = () -> new Person();
        System.out.println(supplier2.get());

        Supplier<Person> supplier3 = Person::new;
        System.out.println(supplier3.get());

        //Function的apply(T t)
        Function<String,Person> function1 = name -> new Person(name);
        System.out.println(function1.apply("tom"));

        Function<String,Person> function2 = Person :: new;
        System.out.println(function2.apply("jerry"));

        //BiFunction的 R apply(T t,U u)
        BiFunction<String,Integer,Person> biFunction1 = (name,age) -> new Person(name,age);
        System.out.println(biFunction1.apply("tom", 23));

        BiFunction<String,Integer,Person> biFunction2 = Person::new;
        System.out.println(biFunction2.apply("jerry", 24));

    }


    //数组引用
    @Test
    public void test4(){
        //Function的R apply(T t)
        Function<Integer,String[]> function1 = length -> new String[length];
        String[] arr1 = function1.apply(10);

        Function<Integer,String[]> function2 = String[]::new;
        String[] arr2 = function2.apply(10);

    }
}