Java8新特性： Lambda helloworld

冷环渊

发布于 2021-12-12 13:39:14

2330

发布于 2021-12-12 13:39:14

Java8 新特性

Java 8 （又称为 jdk 8 ）是java语言开发的一个主要版本，Java8是 oracle 公司 2014 4月发布的，可以看成自java5 以来最具革命性的版本，Java 8 为java 语言，编译器，类库，开发功能与JVM带来了大量的新特性

Java 8 新特性介绍

速度更快
代码更少（增加了新的语法：Lambada 表达式）
强大的 Stream API
便于并行提高程序的运行速度 例：遍历长度为 100k的数组快速排序快了 4.7倍
最大化减少空指针异常 Optional
Nashom 引擎：允许Jvm上运行JS应用

Lambda表达式（重点）

为什么要使用Lambda 表达式

lambda 表达式是一个匿名函数，我们可以把Lambda 表达式理解为是一段可以传递的代码，（将代码像数据一样进行·传递），使用它可以写出更简洁更灵活的代码，作为一种更紧凑的代码风格，使用java的语言表达能力得到了提升.

理论+实践方便理解

Lambda 表达式 coding

简单的用 Lambda做一个hello world的演示

这个语法主要做的就是简化了我们语法
帮我们省去的大多固定要编写的东西
从而达到语法的简化

/**
 * @author : 冷环渊
 * @date : 2021/12/10
 * @context:Lambda 表达式 实操案例
 */
public class LambdaTest {
    /**
     * 示例 1  无参数 传统语法 和 lambda 表达式的区别
     */
    @Test
    public void Test1() {
        // 传统 的 创建一个 线程 打印
        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();

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


        // 用 lambda 表达式 的方法
        Runnable r2 = () -> System.out.println("我爱看北京天安门");
        r2.run();
    }

    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context: 有参数的 Lambda 表达式 传统和 新语法
     * @params :  null
     */
    @Test
    public void Test2() {
        //传统的语法 对象 实现对应方法
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(12, 21);
        System.out.println(compare1);
        System.out.println("***********************");
        /*
         *  lambda表达式 有参数 语法
         *  函数式接口 使用这个接口你一定要实现且只要是先一个接口的时候就可以使用 Lambda 表达式
         *   @FunctionalInterface
         *   public interface Comparator {
         *   int compare(T o1, T o2);
         *    }
         *  使用之后 就变成来很简洁的语法  他代替我们省区了很多已知的东西
         *  Comparator com2 = (o1, o2) -> Integer.compare(o1, o2);
         * */
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(32, 21);
        System.out.println(compare2);
        System.out.println("***********************");

        //我们还可以更加的简化
        //方法引用
        Comparator<Integer> com3 = Integer::compare;
        int compare3 = com3.compare(20, 21);
        System.out.println(compare3);
        System.out.println("***********************");
    }

}

简单的认识了一下 Lambda表达式，我们来看看不同情况下的lambda表达式的语法变化

/**
 * @author : 冷环渊
 * @date : 2021/12/10
 * @context: 
 * 1. 举例子（o1,o2）-> Integeer.compare(o1,o2)
 * 2.格式：
 * -> Lambda操作符 或者叫箭头操作符
 * ()形参列表 相当于是接口中的抽象方法的参数列表，可以省去类型
 * ->右边 Lambda体 其实就是重写抽象对象的方法体
 * 3.Lambda 表达式的使用（有六种情况可以介绍）
 * 4.本质 Lambda 表达式的本质：作为接口的实例
 * 
 */
public class LambdaTest1 {
    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context: 语法格式一 ：没有参数 没有返回值 
     * @params :  null
     */
    @Test
    public void Test1() {
        // 传统 的 创建一个 线程 打印
        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();

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


        // 用 lambda 表达式 的方法
        Runnable r2 = () -> System.out.println("我爱看北京天安门");
        r2.run();
    }

    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context:  语法表达式二 Lambda 需要一个参数 但是没有返回值 
     * @params :  null
     */
    @Test
    public void test2() {
        //传统的区别
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别");
        System.out.println("**************************");
        //使用lambda
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("给你一拳，再给你一拳");
    }

    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context: 语法格式三：数据类型可以省略，因为可以用编译器推算的出，称为 ：”类型推断“ 
     * @params :  null
     */
    @Test
    public void Test3() {
        //使用lambda 还可以再次简化
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("给你一拳，再给你一拳");

        //类型也可以省去
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("我闪避，闪避 miss");
    }

    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context:  类型推断的例子
     * @params :  null
     */
    @Test
    public void Test4() {
        List<String> list = new ArrayList<>();
        int[] arrpub = {
                1, 2, 3
        };
    }

    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context: 语法格式四：Lambda 只需要一个参数的时候，参数的小括号也可以省去
     * @params :  null
     */
    @Test
    public void Test5() {
        //类型也可以省去
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("我闪避，闪避 miss");
        //参数只有一个小括号也可以省去
        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("我闪避，闪避 miss");
    }

    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/10
     * @context: 语法格式五 Lambda 需要两个以上的参数，多条执行语句，且可以有返回值 
     * @params :  null
     */
    @Test
    public void Test6() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(02);
            }
        };
        System.out.println(com1.compare(12, 21));
        System.out.println(" ***************");
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(02);
        };
        System.out.println(com2.compare(12, 21));
    }


    /**
     * @return :  * @return : null
     * @author : 冷环渊
     * @date : 2021/12/11
     * @context: 语法格式六：当Lambda体 只有一条语句的时候，return 与大括号若有都可以忽略 
     * @params :  null
     */
    @Test
    public void Test7() {
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12, 6));
        System.out.println("*********************");
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12, 21));
    }

    @Test
    public void Test8() {
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("想你的夜~~~~~~~~~");
        System.out.println("********************");
        Consumer<String> con2 = s -> System.out.println(s);
        con2.accept("我给你一拳");
    }
}

今天我们就先学习到这里，