java8新特性/内置函数式接口

内置的函数式接口

Lambda 表达式

注意:Lambda表达式只支持函数式接口 也就是 只有一个抽象方法的接口

@FunctionalInterfac e: 检验接口是否是函数式接口

− Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。

• Lambda 表达式的使用

•   1.举例: 1.举例:
  

•      (a,b) -> {
  

•       Integer.compare(a,b);
  

•  };
  

•   2.格式:
  

•      ->:lambda 操作符或者叫箭头操作符
  

•      ->左边:Lambda形参列表,实际上就是接口中抽象方法的形参列表
  

•      ->右边:Lambda体,实际上就是接口中抽象方法的方法体
  

• 总结:

• 左边: Lambda形参列表,中的参数类型可以省略(类型推断) ,如果只有一个参数,一对()也可以省略
  

• 右边:Lambda体,如果Lambda体只有一条语句,可以省略一对{}和return 关键字
  

•  3.Lambda表达式使用:分为六种情况:
  

•  4.Lambda本质:作为函数式接口的实例
  

方式一:无参,无返回值

package com.yzh.controller.lambad;

/**
 * @author
 * @create 2020-06-20 12:32
 * Lambda 表达式的使用
 *       1.举例:(a,b) -> {
 *           Integer.compare(a,b);
 *      };
 *       2.格式:
 *          ->:lambda 操作符或者叫箭头操作符
 *          ->左边:Lambda形参列表,实际上就是接口中抽象方法的形参列表
 *          ->右边:Lambda体,实际上就是接口中抽象方法的方法体
 *
 *      3.Lambda表达式使用:分为六种情况:
 *
 *      4.Lambda本质:作为接口的实例
 */
public class Lambda {
    /**
     * 方式一:无参,无返回值
     */
    public static void main(String[] args) {
        //原来
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是一");
            }

        };
        runnable.run();
    //lambda
   //lambda
    Runnable r = () -> {
        System.out.println("我是一");
    };
    r.run();
    }

}

方式二,一个参数,不需要返回值

public class Lambda {
    /**
     * 方式二,一个参数,不需要返回值
     */
    public static void main(String[] args) {
        //原始
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("我是方式二");
        //*************
        //lambda
        Consumer<String> con = (String str) -> {
            System.out.println(str);
        };
        con.accept("我是lambda2");
    }


}

方式三,参数类型可以省略,由编译器推断出,称为"类型推断"

public class Lambda {
    /**
     * 方式三,参数类型可以省略,由编译器推断出,称为"类型推断"
     */
    public static void main(String[] args) {
        //原始
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("我是方式三");
        //*************
        //lambda
        Consumer<String> con = (str) -> {
            System.out.println(str);
        };
        con.accept("我是lambda2");
    }
}

**

方式四,如果只有一个参数,小括号可以省略

Consumer的语义是消费的意思
这个接口，接收一个泛型的参数T，然后调用accept，对这个参数做一系列的操作，没有返回值；
**

public class Lambda {
    /**
     * 方式四,如果只有一个参数,小括号可以省略
     */
    public static void main(String[] args) {
        //原始
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("我是方式三");
        //*************
        //lambda
        Consumer<String> con = str -> {
            System.out.println(str);
        };
        con.accept("我是lambda2");
    }


}

方式五,如果只有两个或者两个以上的参数,方法体有多条语句,并且有返回值

compareTo() 比较器
方法用于将 Number 对象与方法的参数进行比较。
可用于比较 Byte, Long, Integer等。
该方法用于两个相同数据类型的比较，两个不同类型的数据不能用此方法来比较。

    如果指定的数与参数相等返回0。

    如果指定的数小于参数返回 -1。

    如果指定的数大于参数返回 1。

public class Lambda {
    /**
     * 方式五,如果只有两个或者两个以上的参数,方法体有多条语句,并且有返回值
     */
    public static void main(String[] args) {
        //原始
        //compareTo() 方法用于将 Number 对象与方法的参数进行比较。
        // 可用于比较 Byte, Long, Integer等。
        //该方法用于两个相同数据类型的比较，两个不同类型的数据不能用此方法来比较。

        //如果指定的数与参数相等返回0。

        //如果指定的数小于参数返回 -1。

        //如果指定的数大于参数返回 1。
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        int compare = comparator.compare(1, 2);
        System.out.println(compare);
        //*************
        //lambda
        Comparator<Integer> com = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com.compare(1,2));

    }


}

方式六,当lambda体只有一条语句时,return 和 {} 都可以省略

public class Lambda {
    /**
     * 方式六,当lambda体只有一条语句时,return 和 {} 都可以省略
     */
    public static void main(String[] args) {
        //原始
        //compareTo() 方法用于将 Number 对象与方法的参数进行比较。
        // 可用于比较 Byte, Long, Integer等。
        //该方法用于两个相同数据类型的比较，两个不同类型的数据不能用此方法来比较。

        //如果指定的数与参数相等返回0。

        //如果指定的数小于参数返回 -1。

        //如果指定的数大于参数返回 1。
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

                return o1.compareTo(o2);
            }
        };
        int compare = comparator.compare(1, 2);
        System.out.println(compare);
        //*************
        //lambda
        Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);

        System.out.println(com.compare(1,1));

    }


}