常见函数式接口及其lambda实现样例

常见函数式接口

常见函数式接口的lambda实现

import lombok.*;
import org.junit.Test;
public class LambdaTest {
    private static final int JD_MIN_NO = 1000;
    private static final int JD_NEW_BASE_NO = 10000;

    private static final String JD_PREFIX = "jd-";
      @Test
    public void testLambdaRunnable() {
        Runnable runnable = () -> System.out.println("Hello world");
        runnable.run();
    }

    @Test
    public void testLambdaSupplier() {
        Supplier<Person> supplier = Person::new;
        Person person = supplier.get();
        System.out.println(person);
    }

    @Test
    public void testLambdaConsumer() {
        Person person = new Person();
        person.setName("abc");
        Consumer<Person> consumer = t -> t.setName(JD_PREFIX + t.getName());
        consumer.accept(person);
        System.out.println(person);
    }

    @Test
    public void testLambdaBiConsumer() {
        Person person = new Person();
        person.setName("abc");
        BiConsumer<Person, String> biConsumer = (t, u) -> t.setName(u + t.getName());
        biConsumer.accept(person, JD_PREFIX);
        System.out.println(person);
    }

    @Test
    public void testFunction() {
        Person person = new Person();
        person.setNo(1001);
        person.setName("abc");
        Function<Person, Boolean> function = t -> {
            if (t.getNo() > JD_MIN_NO) {
                t.setName(JD_PREFIX + t.getName());
                return true;
            }
            return false;
        };
        Boolean apply = function.apply(person);
        System.out.println(apply);
    }

    @Test
    public void testBiFunction() {
        Person person = new Person();
        person.setNo(1001);
        person.setName("abc");
        BiFunction<Person, String, Boolean> biFunction = (t, u) -> {
            if (t.getNo() > JD_MIN_NO) {
                t.setName(u + t.getName());
                return true;
            }
            return false;
        };
        Boolean apply = biFunction.apply(person, JD_PREFIX);
        System.out.println(apply);
    }

    @Test
    public void testUnaryOperator() {
        Person person = new Person();
        person.setName("abc");
        UnaryOperator<Person> unaryOperator = t -> {
            t.setName(JD_PREFIX + t.getName());
            return t;
        };
        person = unaryOperator.apply(person);
        System.out.println(person);
    }

    @Test
    public void testBinaryOperator() {
        Person person = new Person();
        person.setName("abc");
        Person newPerson = new Person();
        BinaryOperator<Person> binaryOperator = (t1, t2) -> {
            t2.setName(JD_PREFIX + t1.getName());
            return t2;
        };
        newPerson = binaryOperator.apply(person, newPerson);
        System.out.println(person);
        System.out.println(newPerson);
    }

    @Test
    public void testPredicate() {
        Person person = new Person();
        person.setName("abc");
        Predicate<Person> predicate = t -> t.getName().startsWith(JD_PREFIX);
        boolean result = predicate.test(person);
        System.out.println(result);
    }

    @Test
    public void testBiPredicate() {
        Person person = new Person();
        person.setName("jd-abc");
        BiPredicate<Person, String> predicate = (t, u) -> t.getName().startsWith(u);
        boolean result = predicate.test(person, JD_PREFIX);
        System.out.println(result);
    }
}

@Setter
@Getter
@ToString
@NoArgsConstructor
@AllArgsConstructor
class Person {

    private String name;
    private Integer no;

    public Person(String name) {
        this.name = name;
    }

    public static Person build() {
        return new Person();
    }

    public static void print(String name) {
        System.out.println(name);
    }
}

把lambda表达式赋值给一个接口和当做参数直接传递的区别

从上面的testBiFunction方法可以看到BiFunction<T, U, R> biFunction有三个参数,其中两个是方法的参数类型,一个是返回值类型.而返回值类型是由接受返回值的变量解决定的.而testBinaryOperator方法继承了BiFunction,只是约束了三个参数类型是一样的.当两个实现同时存在时如果不吧lambda表达式赋值给接口引用强制指定其返回值类型,就会优先匹配testBinaryOperator,这与我们初衷不不符.

常见的函数式接口静态方法

TODO

常见的函数式接口default方法

TODO

lambda语法

https://blog.csdn.net/dhbfjh/article/details/103880632