最后一些点

Lambda表达式

package com.www.java1;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * Lambda表达式实质：接口实例
 *
 * 如果一个接口中只有一个抽象方法，则称为函数式接口
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class LambdaTest {
    //语法格式一：无参、无返回值
    @Test
    public void test(){

        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                System.out.println("我爱我家");
            }
        };
        runnable.run();

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

        Runnable runnable1 = () ->{
            System.out.println("我爱我家");
        };
        runnable.run();
    }

    @Test
    public void test1(){
        Comparator<Integer> com = new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        int compare = com.compare(11, 22);
        System.out.println(compare);
        System.out.println("**************");
        //Lambda表达式
        /*(o1,o2) -> Integer.compare(o1,o2)
          ->：Lambda操作符
          ->：左边是Lambda形参列表（就是接口中抽象方法的形参列表）
          ->：右边是Lambda体（就是重写的抽象方法的方法体）
          Lambda表达式的使用（6种）
         */
        Comparator<Integer> com1 = (o1,o2) -> Integer.compare(o1,o2);
        int compare1 = com1.compare(11, 22);
        System.out.println(compare1);
        System.out.println("**************");
        //方法引用
        Comparator<Integer> com2 = Integer :: compare;
        int compare2 = com2.compare(11, 22);
        System.out.println(compare2);
    }

    //语法格式二：有参数，无返回值
    @Test
    public void test2(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("我们都有一个家");
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("名字是中国");
    }

    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断
    @Test
    public void test3(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("名字是中国");
    }

    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("名字是中国");
    }

    //语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5(){
        Comparator<Integer> com = new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                return Integer.compare(o1,o2);
            }
        };

        int compare = com.compare(11, 22);
        System.out.println(compare);
        System.out.println("**************");

        Comparator<Integer> com1 = (o1,o2) -> {
            System.out.println(o1);
            return Integer.compare(o1,o2);
        };
        int compare1 = com1.compare(11, 22);
        System.out.println(compare1);
        System.out.println("**************");
    }

    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    @Test
    public void test6(){
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("名字是中国");
    }
}

方法引用与构造器引用

package com.www.java1;

import org.junit.Test;

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

/**
 * 方法引用
 * 使用要求：接口中的抽象方法形参列表和返回值类型与方法引用的形参列表和返回值类型相同
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class LambdaTest1 {
    //情况一、对象::实例方法
    //Consumer中void accept(T t)
    //PrintStream中void println(T t)
    @Test
    public void test(){
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("名字是中国");

        PrintStream out = System.out;
        Consumer<String> con2 = out :: println;
        con1.accept("名字是中国");
    }

    //情况二、类::静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test1(){
        Comparator<Integer> com1 = (o1, o2) -> Integer.compare(o1,o2);
        int compare1 = com1.compare(11, 22);
        System.out.println(compare1);

        Comparator<Integer> com2 = Integer::compare;
        int compare2 = com2.compare(11, 22);
        System.out.println(compare2);
    }

    //情况三、类：实例方法
    //Comparator中的int compare(T t1,T t2)
    //String中的int t1.compareTo(t2)
    @Test
    public void test2(){
        Comparator<String> com1 = (o1, o2) -> o1.compareTo(o2);
        int compare1 = com1.compare("abd", "abc");
        System.out.println(compare1);

        Comparator<String> com2 = String::compareTo;//当第一个参数作为方法体中方法调用者出现时可以用此方法引用
        int compare2 = com2.compare("abd", "abc");
        System.out.println(compare2);
    }
}

StreamAPI

Optional