学习-函数式编程

函数式接口基础

概念

函数式接口在Java中是指:有且仅有一个抽象方法的接口

格式

只要确保接口中有且仅有一个抽象方法即可:

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息); // 其他非抽象方法内容
} 

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单:

public interface FunctionalVoidTest {
       void method();
}

@FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解:@FunctionalInterface 。该注解可用于一个接口的定义上:

@FunctionalInterface
public interface FunctionalVoidTest {
       void method(String str);
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注 意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

自定义函数式接口
对于刚刚定义好的 FunctionalInterfaceTest 函数式接口，典型使用场景就是作为方法的参数:

public class FunctionalInterfaceTest {

    @Test
    public void testVoid() {
		//标准写法
        FunctionalVoidTest fun = (str -> {
            System.out.println("str = " + str);
        });
        fun.method("1111");

		//简洁写法
        FunctionalVoidTest fun2 = (Str) -> System.out.println("Str = " + Str);
        fun2.method("222");
    }
}

有返回结构样例

@FunctionalInterface
public interface FunctionalReturnTest {
    int cala(int a,int b);

}

public class FunctionalInterfaceTest {
    @Test
    public void test2() {
		//使用另一个方法调用
        int i = test2(1, 2, (m1, m2) -> m1 + m2);
        System.out.println("add= " + i);

        //标准写法
       FunctionalReturnTest add =(a, b)->{
            return a + b;};
        System.out.println("add = " + add.cala(1,2));

       //简洁写法
        FunctionalReturnTest sub = (a, b)-> a-b;
        System.out.println(" sub.cala(2,1) = " + sub.cala(2, 1));


    }
    
    public int test2(int a,int b, FunctionalReturnTest functionalReturnTest) {
        return functionalReturnTest.cala(a,b);
    }

}

函数式编程基础

Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以 作为解决方案，提升性能。

性能浪费的日志案例

注:日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。 一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出:

public class LoggerTest {
    private static void log(int level, String msg) {
        if (level == 1) {
            System.out.println(msg);
        }
    }

    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, msgA + msgB + msgC);
    }
}

这段代码存在问题:无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

备注:SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行 字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进 行字符串拼接。例如: LOGGER.debug(“变量{}的取值为{}。”, “os”, “macOS”) ，其中的大括号 {} 为占位 符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置;否则不会进行字 符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

Lambda的更优写法

使用Lambda必然需要一个函数式接口:

@FunctionalInterface
public interface MessageBuilder {
    String buildMessage();
}

然后对 log 方法进行改造:

  public class LoggerLambdaTest {
    private static void log(int level, MessageBuilder builder) {
        if (level == 1) {
            System.out.println(builder.buildMessage());
        }
    }

    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, () ‐> msgA + msgB + msgC);
    }
}

这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接;否则三个字符串将不会进行拼接。

常用函数式接口-Consumer

java.util.function.Consumer 接口是消费一个数据， 其数据类型由泛型决定。

抽象方法:accept

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如下:

public class FunctionalInterfaceTest {
    @Test
    public void testConsumer() {
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("Hello");

        //方法引用
        consumeString("World", (s) -> System.out.println(s));
    }

    private void consumeString(String param, Consumer<String> function) {
        function.accept(param);
    }
}

当然，更好的写法是使用方法引用。

默认方法:andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果:消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码:

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}

java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出 NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦。
要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况:

public class Demo {
    private static void consumeString(Consumer<String> one, Consumer<String> two) {
        one.andThen(two).accept("Hello");
    }
    
    public static void main(String[] args) {
        consumeString(
                s -> System.out.println(s.toUpperCase()),
                s -> System.out.println(s.toLowerCase()));
    }
}

运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的 组合。

常用函数式接口-Supplier

接口定义如下：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

java.util.function.Supplier 接口仅包含一个无参的方法: T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

或者简单说这个接口只有一个get的抽象类。传入一个泛型T，get方法，返回一个泛型T。

简单使用：

 public class Demo {
    private static String getString(Supplier<String> function) {
        return function.get(); 
    }

    public static void main(String[] args) {
        String msgA = "Hello ";
        String msgB = "World"; 
        System.out.println(getString(() -> msgA + msgB));
    } 
}
//控制台输出 Hello World