lambda表达式与函数式接口（一）

概念

• 有且只有一个抽象方法的接口，称之为函数式接口；该接口可以用@FunctionalInterface注解修饰，确保函数式接口定义的有效性。

/**
 * 函数式接口
 *
 * @author zhuhuix
 * @date 2020-07-12
 */
@FunctionalInterface
public interface FunctionInterface {
    // 有且只有一个抽象方法
    void function();


    // 接口有可以包括其他的方法(静态、默认、私有)
    static void print(){
        System.out.println("这是一个函数式接口中的静态方法");
    }
}

函数式编程

• 可结合lambda表达式作为方法的参数和返回值类型进行使用
  – 关于lambda表达式可能参考 《Java8 lambda函数式编程学习》

案例1：使用函数式接口做为参数

/**
 * 使用lambda表达式重写函数式接口中的抽象方法
 *
 * @author zhuhuix
 * @date 2020-07-12
 */
public class FunctionInterfaceLambda {
    static void callFunctionInterface(FunctionInterface functionInterface) {
    }

    public static void main(String[] args) {
        callFunctionInterface(() ->
                System.out.println("使用lambda表达式重写函数式接口中的抽象方法")
        );
    }
}

案例2：使用函数式接口做为返回值

/**
 * 函数式编程->人员类
 *
 * @author zhuhuix
 * @date 2020-07-11
 */
public class Person {
    //姓名
    private String name;
    //年龄
    private int age;

    public Person(){}

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * 函数式编程->lambda有参数有返回值例子
 *
 * @author zhuhuix
 * @date 2020-07-11
 */
public class PersonArrays {

    public static void main(String[] args) {
        //创建Person数组
        Person[] personArray = {
                new Person("Mike", 20),
                new Person("Jack", 21),
                new Person("Rose", 19)
        };

        // 通过使用Comparator函数式接口进行年龄大小比较实现数组的排序
        Arrays.sort(personArray, Comparator.comparingInt(Person::getAge));

        //遍历Person数组
        for (int i = 0; i < personArray.length; i++) {
            System.out.println(personArray[i].toString());
        }

    }
}

• Comparator.comparingInt 源码如下：

 /**
     * Accepts a function that extracts an {@code int} sort key from a type
     * {@code T}, and returns a {@code Comparator<T>} that compares by that
     * sort key.
     *
     * <p>The returned comparator is serializable if the specified function
     * is also serializable.
     *
     * @param  <T> the type of element to be compared
     * @param  keyExtractor the function used to extract the integer sort key
     * @return a comparator that compares by an extracted key
     * @see #comparing(Function)
     * @throws NullPointerException if the argument is null
     * @since 1.8
     */
    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }

• 程序输出如下：
  

jdk中常用的函数式接口

Supplier接口

• 生产型接口：指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据。

@FunctionalInterface
public interface Supplier<T> {

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

/**
 * 函数式编程--常用函数式接口
 *  * @author zhuhuix
 * @date 2020-07-11
 */
public class FunctionInterfaceDemo2 {
    // Supplier<T>
    public static String getString(Supplier<String> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
        String string = getString(() -> "Supplier函数式接口");
        System.out.println(string);
    }
}

Consumer接口

• 指定接口的泛型是什么类型，那么接口中的accept方法就会使用什么类型的数据。

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
 }

/**
 * 函数式编程--常用函数式接口
 *
 * @author zhuhuix
 * @date 2020-07-11
 */
public class FunctionInterfaceDemo2 {

    // Consume<T>
    public static void acceptString(String string ,Consumer<String> consumer){
        consumer.accept(string);
    }

    public static void main(String[] args) {
        acceptString("Consumer函数式接口",(String string1)-> System.out.println(string1));
    }
}