Java1.8新特性：函数式接口与lambda表达式和方法引用配合使用

lambda表达式

• lambda是一个匿名函数，使用lambda表达式可以有效地使代码变得更加简洁

• 格式：参数 -> {代码}

• 基本实例

//创建线程的步骤
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("1");
    }
});
//lambda写法
new Thread( () -> System.out.println("1"));

• 参数：如果没有参数使用括号，一个参数可以省略括号，多个参数需要使用括号

new HashMap<>().forEach((key,value)
        -> System.out.println("key:" + key + " value:" + value));
new ArrayList<>().forEach( value
        -> System.out.println(value));

• 代码：如果只有一行代码那么可以不写大括号，多行语句必须写大括号

new HashMap<>().forEach((key,value) -> {
    System.out.println("key:" + key);
    System.out.println("value:" + value);
});

• 返回值：如果加了return哪怕只有一行代码也要加大括号，如果不加return可以省略大括号

() -> {return 1};
() -> 1;

方法引用

• 方法引用是通过::来调用方法，方法引用不可以单独使用，需要放在函数式接口中代替lambda表达式使用

• 四种调用方式：

• 静态方法引用

• 实例方法引用

• new方法引用

• 实例对象方法引用

class Father{
    public static void sout(){
        System.out.println("sout");
    }

    public void send(){
        System.out.println("send");
    }
}

public static void main(String[] args) {
    //静态方法
    Father::sout;
    //实例方法
    Father::send;
    //new 方法
    Father::new;
    Father father = new Father();
    father::send;
}

函数式接口

• 函数式接口就是一个接口中有且只有一个抽象方法，然后再接口上加上@FunctionalInterface注解标志他是一个函数式接口，接口中可以有默认方法

• 常见的四种函数式接口：

- 供给型接口：

    - Supplier，没有参数一个返回值 

    - 供给，理解就是你要给别人供给，所以要有一个返回值

//供给型接口 没有参数一个返回值
//提供方法
    public static Object supplier(Supplier<Object> supplier){
        return supplier.get();
    }
    public static void main(String[] args) {
    //方法调用
        supplier(new Supplier<Object>() {
            @Override
            public Object get() {
            //返回值
                return 1;
            }
        });
        //lambda表达式使用
        supplier(() -> 1);
        //方法引用 () -> 1  等价于 Object::new
        //相当于返回了一个Object对象
        supplier(Object::new);
    }

- 消费型接口： 

    - Consumer，一个参数没有返回值 

    - 消费，理解就是你要消费，所以需要一个参数

//消费型接口 一个参数没有返回值
//提供方法
    public static void consumer(int param,Consumer<Integer> consumer){
      consumer.accept(param);
}
    public static void main(String[] args) {
        //方法调用
    consumer(1,new Consumer<Integer>() {
             @Override
         public void accept(Integer integer) {
         //消费参数
              System.out.println(integer);
         }
     });
     //lambda
     consumer(1,integer -> System.out.println(integer));
     //方法引用
     consumer(1,System.out.println(integer));
    }

- 断言型接口： 

    - Predicate，一个参数一个boolean值 

    - 断言，就是给你一个参数你判断然后返回boolean值

//断言型接口  一个参数一个boolean值
    public static boolean predicate(int param,Predicate<Integer> predicate){
        return predicate.test(a);
    }
    public static void main(String[] args) {
        //方法调用
    predicate(1,new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer == 1;
            }
        });
        //lambda
        predicate(1,integer -> 1 == 1);
    }

- 函数型接口： 

    - Function，一个参数一个返回值

//函数式接口 一个参数一个返回值
    public static String function(int param,Function<Integer,String> function){
        return function.apply(param);
    }
    public static void main(String[] args) {
        //方法调用
    function(1,new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return "str";
            }
        });
        //lambda
        function(1,() -> "str");
    }

- 自定义函数式接口

@FunctionalInterface
interface Sum<T>{
    T all(int a,int b);
}
public static int myFunction(int a,int b,Sum<Integer> sum){
        return sum.all(a,b);
    }
public static void main(String[] args){
//调用方法
myFunction(1, 2, new Sum<Integer>() {
     @Override
        public Integer all(int a, int b) {
            return a + b;
        }
    });
    //lambda
myFunction(1, 2, (x, y) -> x * y);
}