Java学习笔记_Lambda学习

　　在Java8之前，如果想“让参数具备行为能力”，即将代码块作为参数进行传递，这是很不方便的。比较普遍的方式就是创建一个类的实例对象，让实例去调用这个方法，从而达到代码块的传递。

1.函数式接口

　　概念：有且仅有一个抽象方法（但可以有其他方法，如：静态方法和默认方法【默认方法主要是为了拓展其实现类时可以不重写接口中的某些方法，提高可拓展性】）的接口，因为只有一个抽象方法才能确保Lambda进行顺利的推导
　　注解：@FunctionalInterface

// JDK内置的函数式接口 JDK1.8提供的内置函数式接口可以在java.util.function包下获

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

2.Lambda

　　语法：类型可以省略写(因为有自动推导的功能，这也是为什么函数式接口只允许有一个抽象方法的原因)，当执行语句只有一条时吗，可以将{}省略，并且将return关键字省去。除此之外,Lambda有延迟加载的功能，在某些场景下可以提升效率。

　　　　无参： ()->{ //执行语句 }
　　　　单参：(T t)->{ //执行语句 }
　　　　　　　(t)->{ //执行语句 }
　　　　多参：(T t, K k)->{ //执行语句 }

/**
 * @Created by zhenjun_gan
 * @Date 2020/6/9
 * 自定义函数式接口
 */
@FunctionalInterface
public interface MyFunction {
    void myMethod();
}

// 测试类
public class LambdaExample {

    public static void main(String[] args) {
        //传统的开启线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开启线程1");
            }
        }).start();
        // Lambda简化
        new Thread(() -> {
            System.out.println("开启线程3");
        }).start();

        new Thread(() -> System.out.println("开启线程2")).start();

        //使用Lambda遍历集合
        Arrays.asList(1, 2, 2, 4, 1, 66, 3, 778, 0).forEach((num) -> System.out.println(num));

        //测试函数式接口
        int y = 12;
        int x = 10;
        String result1 = adder(x, y, new BiFunction() {
            @Override
            public Object apply(Object o, Object o2) {
                return "" + x + y;
            }
        });
        //Lambda简化
        String result3 = adder(x, y, (a, b) -> {
            return "" + a + b;
        });
        //省略 return 和{}
        String result2 = adder(x, y, (a, b) -> "" + a + b);
        System.out.println(result1);// 1012
        System.out.println(result2);// 1012
        System.out.println(result3);// 1012

        // 延迟执行
        testFunction(2, () -> System.out.println("执行function.myMethod..."));
    }
    //测试自定义的函数式接口
    public static void testFunction(int a, MyFunction function) {
        if (a == 1) {
            System.out.println("执行testFunction...");
            function.myMethod();
        }
    }
    //做一个字符串的添加
    public static String adder(Integer x, Integer y, BiFunction<Integer, Integer, String> fun) {
        return fun.apply(x, y);
    }
}

3.java8提供的常用函数式接口

　　Consumer<T>(消费)
　　Supplier<T>(生产)
　　Function<T,R>(转换)
　　Predicate<T>(断言)

class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    // 重写equals ...
    //getter and setter ...
}

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
 * @Created by zhenjun_gan
 * @Date 2020/6/10
 * 常用的函数式接口
 */
public class CommonFunctionLambdaExample {

    public static void main(String[] args) {

        Person person1 = testSupplier(() -> new Person("张三"));
        System.out.println(person1);//Person{ name='张三'}

        Person person2 = new Person("李四");
        testConsumer(person2, person -> System.out.println(person));//Person{ name='李四'}

        String name = "王五";
        Person person3 = testFunction(name, pName -> new Person(pName));//Person{ name='王五'}
        System.out.println(person3);

        Person person = new Person("老刘");
        Person person4 = new Person("老刘");
        Person person5 = new Person("老王");
        System.out.println(testPredicate(person4, p -> person.equals(p)));//true
        System.out.println(testPredicate(person5, p -> person.equals(p)));//false
    }

    // 生产一个Person对象(生产)
    public static Person testSupplier(Supplier<Person> supplier) {
        return supplier.get();
    }

    // 消费一个Person对象(消费)
    public static void testConsumer(Person person, Consumer<Person> consumer) {
        consumer.accept(person);
    }

    //消费一个name生产一个Person(转换)
    public static Person testFunction(String name, Function<String, Person> function) {
        return function.apply(name);
    }

    //判断(断言)
    public static boolean testPredicate(Person person, Predicate<Person> predicate) {
        return predicate.test(person);
    }
}

4.结语

java中的函数式接口其实单独使用并没有什么太大的意义，只是相比于传统的代码简化了而已，但是也降低了代码的可读性。Java中使用Lambda主要是为了与Stream结合，在实际工作中也是与Stream结合对数据进行一些操作，与传统的数据集操作相比更具优雅性，同时效率也更高。