java8 新特性之Lambda 表达式

应用场景
1. for循环
2. 线程中的匿名内部类
3. 比较器中的匿名内部类
新建 Expression.class

import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
import java.util.List;

/**
 * Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。
 *
 * Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
 * Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
 *
 * (parameters) -> expression
 * 或
 * (parameters) ->{ statements; }
 *
 *  以下是lambda表达式的重要特征:
 * 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
 * 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
 * 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
 * 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
 */
@Slf4j
public class Expression {


    /**
     *  for循环
     *  匿名内部类
     *  排序-匿名内部类
     *
     */
    public static void main(String[] args) {
        Expression expression = new Expression();
//        expression.test01();
//        expression.test02();
        expression.test03();
    }

    /**
     * for 循环
     */
    public void  test01(){
        String[] atp = {"Rafael Nadal", "Novak Djokovic",
                "Stanislas Wawrinka",
                "David Ferrer","Roger Federer",
                "Andy Murray","Tomas Berdych",
                "Juan Martin Del Potro"};

        List<String> lists = Arrays.asList(atp);
//        for(String str: lists){
//             log.info(str);
//        }

        log.info("----------------------------");
//        lists.forEach(entry -> log.info(entry));
//        lists.forEach(entry -> {
//            log.info(entry);
//        });

//        lists.forEach((entry) -> {
//            log.info(entry);
//        });

//        lists.forEach((String entry) -> {
//            log.info(entry);
//        });

        // 使用双冒号操作符
        lists.forEach(System.out::println);
    }

    /**
     * 匿名内部类
     */
    public void test02(){
        // 传统写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                log.info("传统写法的 匿名内部类");
            }
        }).start();

        // 使用 lambda 表达式
        new Thread(() -> {
            log.info("使用 lambda 实现匿名内部类");
        }).start();

        // 传统方式 使用 匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                log.info("使用匿名 内部类");
            }
        };
        runnable.run();

        Runnable lambda= () -> {
            log.info("lambda 实现匿名内部类");
        };
        lambda.run();
    }


    /**
     *  比较器
     *
     */
    public void test03(){
        String[] atp = {"Rafael Nadal", "Novak Djokovic",
                "Stanislas Wawrinka",
                "David Ferrer","Roger Federer",
                "Andy Murray","Tomas Berdych",
                "Juan Martin Del Potro"};
        // public static <T> void sort(T[] a, Comparator<? super T> c)
//        Arrays.sort(atp, new Comparator<String>() {
//            @Override
//            public int compare(String str01, String str02) {
//                return str01.compareTo(str02);
//            }
//        });


        // lambda 表达式写法
        Arrays.sort(atp, (String first, String second) -> {
            return first.compareTo(second);
        });

        List<String> lists = Arrays.asList(atp);
        lists.forEach(entry -> log.info(entry));
    }


}