JDK新特性

1 Java 8 新特性简介

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。Java 8 是oracle公司于2014年3月发布，可以看成是自Java 5 以来最具革命性的版本。 Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。

2 Lambda表达式

2.1 简介

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升
从匿名类到 Lambda 的转换举例1 ：

public class LamdbaDemo2 {

    /**
     * junit主线程结束，会结束所有子线程
     * @param args
     */
    public static void main(String[] args) {

//        Runnable myTask = new Runnable() {
//            @Override
//            public void run() {
//                for (int i = 1; i <= 100; i++) {
//                    System.out.println(Thread.currentThread().getName() + " "  +  i);
//                }
//            }
//        };

        Runnable myTask = () -> {
            for (int i = 1; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + " "  +  i);
            }
        };

        for (int i = 0; i < 4; i++) {
            new Thread(myTask).start();
        }

        System.out.println("main over");
    }

}

从匿名类到 Lambda 的转换举例2 ：

public class LamdbaDemo4 {

    public static void show(A a) {
        a.f1();
    }

    public static void main(String[] args) {
//        A a = new A() {
//            @Override
//            public void f1() {
//                System.out.println("a f1");
//            }
//
//            @Override
//            public void f2() {
//                System.out.println("a f2");
//            }
//
//        };
//        show(a);

        //如果2个抽象方法不能使用lambda表达式
        show(() -> {
            System.out.println("a lambda f1");
        });

    }

    @FunctionalInterface
    interface A {
        void f1();
    }

    interface B {
        void f2();
    }

}

2.2 语法

Lambda 表达式： 在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda

操作符或箭头操作符。它将 Lambda 分为两个部分：

• 匿名内部类实现的接口一定是函数接口（只有一个抽象方法的接口）
• 左侧： 指定了 Lambda 表达式需要的参数列表
• 右侧： 指定了 Lambda 体， 是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能

2.3 类型推断

Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断” 。

一个参数：

/**
 * 一个参数的语法
 */
public class LamdbaDemo5 {

    public static void show(B b) {
        b.f1("hello lambda 表达式");
    }

    /**
     * 匿名内部类
     */
    public void test1() {
        //匿名内部类
        B b = new B() {
            @Override
            public void f1(String s) {
                System.out.println(s);
            }
        };
        show(b);
    }

    /**
     * lambda表达式
     */
    @Test
    public void test2() {
        //匿名内部类
//        B b = (String str) -> {
//            System.out.println(str);
//        };
//        show(b);

        show((String str) -> {
            System.out.println(str);
        });
    }

    /**
     * lambda表达式左边参数列表，可以根据上下文判断参数类型
     */
    @Test
    public void test3() {
        show((str) -> {
            str += " hello abc";
            System.out.println(str);
        });
    }

    /**
     * 只有一个参数
     */
    @Test
    public void test4() {
        show(str -> {
            str += " hello abc";
            System.out.println(str);
        });
    }

    @FunctionalInterface
    interface B {
        void f1(String s);
    }


}

两个参数：

/**
 * 多个参数的语法
 */
public class LamdbaDemo6 {

    public static void show(C c) {
        c.f1(10, 20);
    }

    /**
     * 打印两个数的大的值
     */
    @Test
    public void test1() {
        C c = new C() {
            @Override
            public void f1(int x, int y) {
                System.out.println(x > y ? x : y);
            }
        };
        show(c);
    }

    @Test
    public void test2() {
        show((x, y) -> {
//            System.out.println(x > y ? x :y);
            System.out.println(x + y);
        });
    }


    @FunctionalInterface
    interface C {
        void f1(int x, int y);
    }

    @Test
    public void test3() {
        List list = new ArrayList();

        list.add("555");
        list.add("zzz");
        list.add("xxx");
        list.add("yyy");
        list.add("mmm");
        list.add("nnn");
        list.add("aaa");
        list.add("aaa");
        list.add("111");
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");

        Comparator com = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                String s1 = (String) o1;
                String s2 = (String) o2;
                return -s1.compareTo(s2);
            }

        };
        Collections.sort(list, com); //定制排序

        System.out.println(list);
    }


    @Test
    public void test4() {
        List list = new ArrayList();

        list.add("555");
        list.add("zzz");
        list.add("xxx");
        list.add("yyy");
        list.add("mmm");
        list.add("nnn");
        list.add("aaa");
        list.add("aaa");
        list.add("111");
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");

//        Comparator com = new Comparator() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                String s1 = (String) o1;
//                String s2 = (String) o2;
//                return -s1.compareTo(s2);
//            }
//
//        };

        //定制排序器
        Comparator<String> com = (s1, s2) -> {
            return -s1.compareTo(s2);
        };
        Collections.sort(list, com); //定制排序

        System.out.println(list);
    }



}