Lambada表达式

Lambada 表达式用来简化匿名内部类的写法,

只要是函数式接口就可以用 Lambda 表达式简化
//函数式接口： 接口中有且只有⼀个未实现的⽅法，这个接口就叫函数式接口
//函数式接口用@FunctionalInterface 注解

无 lambada 表达式之前：

• 匿名内部类
• 实现类

以下是使用对比：

//函数式接口
interface MyInterface {
    int sum(int i, int j);
}

//方法1：实现类
public class MyInterfaceImpl implements MyInterface {
    @Override
    public int sum(int i, int j) {
        return i + j;
    }
}

public class Test {
 public static void main(String[] args) {
    //方法1：
    MyInterface myInterface = new MyInterfaceImpl();

    //方法2：匿名内部类：
    MyInterface myInterface = new MyInterface() {
    @Override
    public int sum(int i, int j) {
        return i + j;
    }
    };

    //方法3：Lambda 表达式
    MyInterface myInterface = (i, j) -> i + j;

  System.out.println(myInterface.sum(1, 2));
 }
}

Lambada 表达式

(参数列表) ->

最佳使用方式：以后调用某个方法传入的参数，这个参数实例是一个接口对象，并且定义了一个方法，就可以直接用 lambada 表达式。

//原来要传入实例，写匿名内部类
Collections.sort(name,new Comparator<String>(){
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
})

//使用lambada表达式
Collections.sort(name,(String o1, String o2)->{
    return o1.compareTo(o2);
})

Function 函数式各种写法

函数式接⼝的出⼊参定义：

1. 有⼊参，⽆出参【消费者】： function.accept

BiConsumer<String,String> function = (a,b)->{ //能接受两个⼊参
    System.out.println("哈哈："+a+"；呵呵："+b);
};

    function.accept("1","2");

2. 有⼊参，有出参【多功能函数】： function.apply

Function<String,Integer> function = (String x) -> Integer.parseInt(x);
System.out.println(function.apply("2"));

3. ⽆⼊参，⽆出参【普通函数】：

Runnable runnable = () -> System.out.println("aaa");
new Thread(runnable).start();

4. ⽆⼊参，有出参【提供者】： function.get

Supplier<String> supplier = ()-> UUID.randomUUID().toString();
String s = supplier.get();
System.out.println(s);

java.util.function 包下的所有 function 定义：
Consumer： 消费者
Supplier： 提供者
Predicate： 断⾔
get/test/apply/accept 调用的函数⽅法；

public static void checkOdd(Supplier<Integer> supplier,
                           Predicate<Integer> predicate,
                           Function<Boolean, String> function,
                           Consumer<String> consumer) {
    // 1. Supplier 提供数字
    Integer num = supplier.get();
    // 2. Predicate 判断是否为奇数
    boolean isOdd = predicate.test(num);
    // 3. Function 将布尔结果转换为字符串描述
    String result = function.apply(isOdd);
    // 4. Consumer 打印输出结果
    consumer.accept(result);
}

// 调用示例
checkOdd(() -> 7,
         num -> num % 2 != 0,
         isOdd -> isOdd ? "是奇数" : "是偶数",
         System.out::println);

.get() .test() .apply() .accept() 调用的都是传入的方法体。