1、方法参数以往都是类，变量属性，但是并没有当函数作为入参，而函数入参是有必要的
对于有些方法入参其实只需要一个函数操作后的结果，我不需要知道什么参数类型啊
大大减少了很多不必要的代码，什么创建匿名类啊
但是上手需要一段时间，改变编程习惯和思维需要一段时间

package com.delicacy.oatmeal.java.lamdba;

import lombok.Data;

/**
 * function demo
 * @author zyt
 * @create 2018-04-15 16:40
 **/
public class FunctionInterfaceDemo {

    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(11);
        person.setName("tom");
        person.selfintroduc(e->{return "我叫"+e.getName()+",我今年"+e.getAge(); });

    }

}

@Data
class Person{
    private String name;
    private int age;

    public void selfintroduc(Action<Person> action){
        System.out.println(action.selfintroduce(this));
    }

}

//声明函数接口的注解
@FunctionalInterface
interface Action<T> {
    String selfintroduce(T t);
}

2、下面提供自己所写几个简单的工具类，只是提供简单的思路，还是可以再完善（比如方法内部可以加redisson锁，或者返回自定义的返回值等）

package com.delicacy.oatmeal.java.lamdba;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * 常用操作类函数是接口
 *
 * @author zyt
 * @create 2018-04-15 17:23
 **/
public class FunctionUtil {

    //如果存在，则更改，否则插入
    public static <T> void save(T t, Predicate<T> predicate, Consumer<T> consumer1 ,Consumer<T> consumer2) {
        if (predicate.test(t)) consumer1.accept(t);
        else  consumer2.accept(t);
    }

    //如果不存在，则新增
    public static <T> void add(T t, Predicate<T> predicate, Consumer<T> consumer) {
        if (!predicate.test(t)) consumer.accept(t);
    }

    //如果存在，则更改
    public static <T> void update(T t, Predicate<T> predicate, Consumer<T> consumer) {
        if (predicate.test(t)) consumer.accept(t);
    }


    //如果存在，则更改，否则插入
    public static <T,R> R save(T t, Predicate<T> predicate, Function<T,R>  function1, Function<T,R>  function2) {
        if (predicate.test(t)) return function1.apply(t);
        else  return function2.apply(t);
    }

    //如果存在，则更改，否则插入
    public static <T,R> R saveList(List<T> ts, Predicate<List<T>> predicate, Function<List<T>,R>  function1,Function<List<T>,R>  function2) {
        if (predicate.test(ts)) return function1.apply(ts);
        else  return function2.apply(ts);
    }

}