JDK8新特性(一) Lambda表达式及相关特性

函数式接口

函数式接口是1.8中的新特性，他不属于新语法，更像是一种规范

面向对象接口复习

在这里先回顾一下面向对象的接口，创建接口的关键字为 interface ，这里创建一个日志接口：

public interface LogService {

    void info();

}

众所周知，Java中的接口是不能直接创建实例的，因为他的抽象方法没有得到实现：

当我们想要创建接口实例的时候一般都通过实现类来获取实例：

public class LogServiceImpl implements LogService {

    @Override

    public void info() {

        System.out.println("哈哈哈哈");

    }

}

这样我们就可以通过实现来创建这个接口的实例：

public class ApplicationMain {

    public static void main(String[] args) {

        LogService log = new LogServiceImpl();

        log.info();

    }

}

对接口中的方法进行实现除了实现类之外，还可以通过匿名内部类的方式来创建接口的实例：

public class ApplicationMain {

    public static void main(String[] args) {

        LogService log = new LogService() {

            @Override

            public void info() {

                System.out.println("嘿嘿嘿");

            }

        };

    }

}

什么是函数式接口

当一个接口只有一个抽象方法 ( 接口默认实现不算 ) 的时候这个接口就是函数式接口 ，上面的 LogService 就属于函数式接口，还有学习线程时的 Runnable 接口也属于函数式接口

函数式接口还有一个注解为 @FunctionalInterface ，据我了解这个注解可有可无，它主要起到的是检查的作用，当接口中的抽象方法数量大于1的时候就会报错：

内置常用函数式接口

Java中内置了一些常用的函数式接口，这里介绍其中的四种，不用刻意去记，用到就明白了

函数式接口	参数	返回值	说明
Consumer	T	void	对类型为T的实例进行操作
Supplier	无	T	返回类型为T的实例
Function<T, R>	T	R	通过对T的操作返回R的实例
Predicate	T	boolean	通过对T的操作返回boolean值

通过巧妙的运用函数式接口可以实现回调函数的功能

Lambda表达式

Lambda表达式是1.8中的新特性， 主要针对函数式接口的匿名内部类实现做了简化

表达式基本语法

找到上面匿名内部类创建 LogService 的代码：

public class ApplicationMain {

    public static void main(String[] args) {

        LogService log = new LogService() {

            @Override

            public void info() {

                System.out.println("嘿嘿嘿");

            }

        };

    }

}

因为创建的实例就是接口本身，所以 new 的部分就可以省略不写，接口中需要实现的抽象方法只有一个，那么也没有必要指定具体实现的方法名称，简写后如下所示：

public class ApplicationMain {

    public static void main(String[] args) {

        LogService log = ()->{

            System.out.println("哈哈哈哈");

        };

        log.info();

    }

}

Lambda表达式前面的括号 ( ) 就代表参数列表，箭头 -> 后面的代码块就代表着实现的具体方法体，如果 info 方法中有参数就可以这样写：

public class ApplicationMain {

    public static void main(String[] args) {

        LogService log = (msg)->{

            System.out.println(msg);

        };

        log.info("老八秘制小汉堡");

    }

}

使用Lambda表达式创建一个线程：

public class ApplicationMain {

    public static void main(String[] args) {

        // Runnable为函数式接口，所以可以使用Lambda表达式

        new Thread(()->{

            System.out.println("另一条线程");

        }).start();

        System.out.println("Main主线程");

    }

}

表达式的简写

使用Lambda表达式代替匿名内部类的写法非常简洁，但是在满足特定条件的情况下，它还可以更简洁：

public class ApplicationMain {

    public static void main(String[] args) {

        /**

         * 在参数列表只有一个参数的情况下，()可以省略不写

         * 当代码块中只有一句代码时{}可以省略不写

         * 当函数有返回值且代码块中只有一句代码时return可以省略不写

         */

        LogService log = msg->System.out.println(msg);

        log.info("老八秘制小汉堡");

    }

}

Lambda表达式相比匿名内部类还有一个特点，当使用匿名内部类时会为匿名内部类生成一个class文件，而使用Lambda表达式时就不会额外生成class文件，这个不做重点

方法引用

方法引用是1.8中的新特性，配合Lambda表达式使用可以让代码更简洁

方法引用初体验

方法引用中需要的特殊符号为双冒号 :: ，具体表现为以下形式：

表现形式	作用
对象::实例方法	通过对象调用实例中的方法
类::实例方法	通过类调用实例中的方法
类::静态方法	通过类调用实例中的静态方法
类::new	创建该类的实例

当Lambda表达式中只有一句函数调用代码，且调用的目标函数的参数列表和Lambda表达式接收的参数列表一致时就可以使用方法引用 ，如下所示：

public class ApplicationMain {

    public static void main(String[] args) {

        // 代表的就是上面表格中表现形式的第一行  对象::实例方法

        LogService log = System.out::println;

        log.info("老八秘制小汉堡");

        // forEach同样可以使用方法引用

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        list.forEach(System.out::println);

    }

}

综合练习

针对上面的函数式接口，Lambda表达式以及方法引用做练习，代码会有些多：

/**

 * 综合练习

 *   函数式接口 + Lambda表达式 + 方法引用

 */

public class ApplicationMain {

    public static void main(String[] args) {

        // 方法引用  对象::实例方法

        strToDate("2021-2-20 22:08:45", System.out::println);

        // 方法引用  类::new

        System.out.println(dateToStr(Date::new));

        // 回调函数：取最大值

        Integer integer = strListToIntList(Arrays.asList("135", "541", "244"), list -> {

            int maxNumber = 0;

            for (Integer item : list) {

                if (item > maxNumber) {

                    maxNumber = item;

                }

            }

            return maxNumber;

        });

        System.out.println("最大值为：" + integer);

        // 实现过滤器功能

        List<Integer> list = filter(Arrays.asList(800, 200, 1200, 600, 3000, 2400), item -> item > 1000);

        System.out.println(list);

    }

    // Consumer：通过时间字符串快速获取Date对象

    public static void strToDate(String date, Consumer<Date> consumer) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date parse = null;

        try {

            parse = sdf.parse(date);

        } catch (ParseException e) {

            System.err.println("转换失败！");

        }

        consumer.accept(parse);

    }

    // Supplier：通过Date对象快速获取到时间字符串

    public static String dateToStr(Supplier<Date> supplier) {

        Date date = supplier.get();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        return sdf.format(date);

    }

    // Function：将String集合转换为Integer，后续操作交给调用者

    public static Integer strListToIntList(List<String> list, Function<List<Integer>, Integer> function) {

        ArrayList<Integer> integerList = new ArrayList<>();

        for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {

            String next = iterator.next();

            Integer integer = Integer.valueOf(next);

            integerList.add(integer);

        }

        return function.apply(integerList);

    }

    // predicate：返回大于1000的数字

    public static List<Integer> filter(List<Integer> list, Predicate<Integer> predicate) {

        ArrayList<Integer> target = new ArrayList<>();

        for (Integer item : list) {

            if (predicate.test(item)) {

                target.add(item);

            }

        }

        return target;

    }

}