我们先来写一个类里面的接口

interface IMoneyFormat{
    String format(int i);
}

然后定义一个私有类

class MyMoney{
    private final int money;
    public MyMoney(int money){
        this.money = money;
    }

    public void printMoney(IMoneyFormat moneyFormat) {
        System.out.println("我的存款：" + moneyFormat.format(this.money));
    }
}

最后写个共有类调用它

public class MyMoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(100000);
        me.printMoney(i -> new DecimalFormat("#,###").format(i));
    }
}

运行 main 方法，打印出下面的内容

image

之前说过， lambda 表达式不关心你实现的是哪个接口，好比它不需要知道你接口名，方法名，它只要知道输入是什么，输出是什么。所以，在上面的例子中，其实我们不要定义一个接口，只要定义一个输入是 int 类型，输出是 String 类型的函数即可。

将上面的代码改成如下的：

class MyMoney2{
    private final int money;
    public MyMoney2(int money){
        this.money = money;
    }

    public void printMoney(Function<Integer, String> moneyFormat) {
        System.out.println("我的存款：" + moneyFormat.apply(this.money));
    }
}

然后在 main 调用时改成 用 MyMoney2，运行 main 方法，也能得到同样的结果。这就能节省我们定义接口的工作了。

还可以这样玩

    public static void main(String[] args) {
        MyMoney2 me = new MyMoney2(100000);
        Function<Integer, String> moneyFormat = i -> new DecimalFormat("#,###").format(i);
//        函数接口链式操作
        me.printMoney(moneyFormat.andThen(s -> "RMB " + s));
    }

image

这样不仅可以定义更少的接口，还能更灵活的实现接口。

总的函数接口如下：

image

以上这些都是可以很灵活使用的，下面我举两个例

    public static void fuctionTest(){
//        断言函数接口
        Predicate<Integer> predicate = i -> i > 0;
        System.out.println(predicate.test(-1));
//        消费函数接口
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("input data");
    }

然后在 main 方法里面调用这个方法，输出如下

image

同时，你还可以使用 IntPredicate、IntConsumer 等等，这样子定义类型都可以省略了。

    public static void fuctionTest2(){
//        断言函数接口
        IntPredicate predicate = i -> i > 0;
        System.out.println(predicate.test(-1));
//        消费函数接口
        IntConsumer consumer = s -> System.out.println(s);
        consumer.accept(99);
    }

代码地址： https://github.com/hmilyos/lambda-demo.git