Skip to Content

Java8函数式接口

Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即Java不但可以支持OOP还可以支持OOF（面向函数编程）。

在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。

在Java8中，Lambda表达式就是一个函数式接口的实例。只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

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

函数式接口适用于函数式编程场景的接口。可以通过 Lambda 表达式来创建该接口的对象。

若 Lambda 表达式抛出一个受检异常，即非运行时异常，那么该异常需要在目标接口的抽象方法上进行声明。

格式

只要确保接口中有且仅有一个抽象方法即可（可以有其他默认方法、静态方法、私有方法）：

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

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

public interface MyFunctionalInterface { 
    void myMethod();
}

@FunctionalInterface注解

与@Override注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解，可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

// 函数式接口的定义：
@FunctionalInterface
public interface MyFunctionalInterface { 
    void myMethod();
}
 
// 函数式接口的使用：
public class DemoFunctionalInterface {
    // 使用自定义的函数式接口作为方法参数
    private static void doSomething(MyFunctionalInterface inter) { 
        inter.myMethod(); // 调用自定义的函数式接口方法
    }
    public static void main(String[] args) {
        // 调用使用函数式接口的方法
        doSomething(() ‐> System.out.println("Lambda执行啦！"));
    }
}

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

四大核心函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在在java.util.function包中被提供。

Supplier接口

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

import java.util.function.Supplier;
public class Demo08Supplier {
    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));
    }
}

Consumer接口

java.util.function.Consumer<T>接口则与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

抽象方法accept

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

import java.util.function.Consumer;
public class Demo09Consumer {
    private static void method(String name, Consumer<String> con) { 
        con.accept(name);
    }
    public static void main(String[] args) {
        method("乔木先生", name -> System.out.println("我的名字是" + name));
    }
}

默认方法andThen

如果一个方法的参数和返回值全都是Consumer类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是Consumer接口中的default方法andThen。要想实现组合，需要两个或多个Lambda表达式即可，而andThen的语义正是“一步接一步”操作。例如两个步骤组合的情况：

import java.util.function.Consumer;
public class Demo10ConsumerAndThen {
    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。当然，通过链式写法可以实现更多步骤的组合。

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate接口。

抽象方法test

Predicate接口中包含一个抽象方法：boolean test(T t)。用于条件判断的场景：

import java.util.function.Predicate;
public class Demo15PredicateTest {
    private static void method(Predicate<String> predicate) { 
        boolean veryLong = predicate.test("HelloWorld");
        System.out.println("字符串很长吗：" + veryLong);
    }
    public static void main(String[] args) {
        method(s ‐> s.length() > 5);
    }
}

条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

默认方法and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个Predicate条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法and。

如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：

import java.util.function.Predicate;
public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) { 
        boolean isValid = one.and(two).test("Helloworld");
        System.out.println("字符串符合要求吗：" + isValid);
    }
    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

默认方法or

与and的“与”类似，默认方法or实现逻辑关系中的“或”。

如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将and修改为or名称即可，其他都不变：

import java.util.function.Predicate;
public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) { 
        boolean isValid = one.or(two).test("Helloworld");
        System.out.println("字符串符合要求吗：" + isValid);
    }
    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

默认方法negate

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行!取反而已。一定要在test方法调用之前调用negate方法，正如and和or方法一样：

import java.util.function.Predicate;
public class Demo17PredicateNegate {
    private static void method(Predicate<String> predicate) {
        boolean veryLong = predicate.negate().test("HelloWorld"); 
        System.out.println("字符串很长吗：" + veryLong);
    }
    public static void main(String[] args) {
        method(s ‐> s.length() < 5);
    }
}

Function接口

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

抽象方法apply

Function 接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。

使用的场景例如：将String类型转换为Integer类型。

import java.util.function.Function;
public class Demo11FunctionApply {
    private static void method(Function<String, Integer> function) { 
        int num = function.apply("10");
        System.out.println(num + 20);
    }
    public static void main(String[] args) {
        method(s ‐> Integer.parseInt(s));
    }
}

当然，最好是通过方法引用的写法。

默认方法andThen

Function接口中有一个默认的andThen方法，用来进行组合操作。

import java.util.function.Function;
public class Demo12FunctionAndThen {
    private static void method(Function<String, Integer> one, Function<Integer, Integer> two) { 
        int num = one.andThen(two).apply("10");
        System.out.println(num + 20);
    }
    public static void main(String[] args) {
        method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
    }
}

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过andThen按照前后顺序组合到了一起。

Function的前置条件泛型和后置条件泛型可以相同。

其他接口

函数式接口参数类型返回类型用途
BiFunction<T, U, R>T, UR对类型为T, U参数应用操作，返回R类型的结果。包含方法为：R apply(T t, U u);
UnaryOperator(Function子接口)TT对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为：T apply(T t);
BinaryOperator(BiFunction子接口)T, TT对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为：T apply(T t1, T t2);
BiConsumer<T, U>T, Uvoid对类型为T, U参数应用操作。包含方法为：void accept(T t, U u)
BiPredicate<T,U>T,Uboolean包含方法为：boolean test(T t,U u)
ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>Tint long double分别计算int、long、double值的函数
IntFunction<R> LongFunction<R> DoubleFunction<R>int long doubleR参数分别为int、long、double类型的函数
Last updated on