Java8 伪函数指针（Function、BiFunction）

Function接口源码

package java.util.function;

import java.util.Objects;

/**
 * Represents a function that accepts one argument and produces a result.
 *
 * 
This is a "package-summary.html">functional interface
 * whose functional method is {@link #apply(Object)}.
 *
 * @param  the type of the input to the function
 * @param  the type of the result of the function
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Function {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param  the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default  Function compose(Function before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param  the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default  Function andThen(Function after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param  the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static  Function identity() {
        return t -> t;
    }
}

BiFunction接口源码

package java.util.function;

import java.util.Objects;

/**
 * Represents a function that accepts two arguments and produces a result.
 * This is the two-arity specialization of {@link Function}.
 *
 * 
This is a "package-summary.html">functional interface
 * whose functional method is {@link #apply(Object, Object)}.
 *
 * @param  the type of the first argument to the function
 * @param  the type of the second argument to the function
 * @param  the type of the result of the function
 *
 * @see Function
 * @since 1.8
 */
@FunctionalInterface
public interface BiFunction {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param  the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     */
    default  BiFunction andThen(Function after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

应用实例

package com.demo.test;

import java.util.function.BiFunction;
import java.util.function.Function;

public class FunctionDemo {

    public static void main(String[] args) {
        java7_biFunction();
        java8_biFunction();
    }

    private static void java7_biFunction() {
        BiFunction bi = new BiFunction(){
            @Override
            public String apply(String t, String u) {
                return t+u;
            }
        };
        Function func = new Function() {
            @Override
            public String apply(String t) {
                return t+"-then";
            }
        };
        System.out.println(func.apply("test"));//test-then
        System.out.println(bi.apply("java2s.com", "-tutorial"));//java2s.com-tutorial
        System.out.println(bi.andThen(func).andThen(func).apply("java2s.com", "-tutorial"));//java2s.com-tutorial-then-then
    }

    private static void java8_biFunction() {
        //java8新特性，lambda表达式
        BiFunction bi = (x, y) -> {
            return x + y;
        };
        Function func = x-> x+"-then";
        System.out.println(func.apply("test"));//test-then
        System.out.println(bi.apply("java2s.com", "-tutorial"));//java2s.com tutorial
        System.out.println(bi.andThen(func).andThen(func).apply("java2s.com", "-tutorial"));//java2s.com-tutorial-then-then
    }
}

参考

• http://www.java2s.com/Tutorials/Java_Lambda/java.util.function/BiFunction/BiFunction_example.htm
• http://www.java2s.com/Tutorials/Java_Lambda/java.util.function/BiFunction/BiFunction_andThen_example.htm