JDK1.8新特性

1. 接口增强，允许接口定义静态方法 和 默认方法

public interface JDK8Interface {

    // 静态方法，可以定义多个，只能接口调用
    static void testStatic() {
        System.out.println("testStatic");
    }

    // 默认方法，可以定义多个，只能接口实现类的对象调用，子类也可以重写，可以作为公共默认实现
    default void testDefault() {
        System.out.println("testDefault");
    }

}

2. Lambda表达式，只能用于只有一个抽象方法方法的接口
   基本用法：

public interface JDK8Interface {

    int method(int a);

}

class test {

    public static void main(String[] args) {

        // 等于创建了一个实现JDK8Interface接口的类，并重写了method方法，并创建了类的实例对象jdk8Class
        // （int a）可以简写为（a）->，也可以简写为a ->
        // 是不是很像匿名内部类
        JDK8Interface jdk8Class = (int a) -> {
            return a + 1;
        };

        // 调用对象的method()方法
        int value = jdk8Class.method(23);
        System.out.println(value);

    }
    
}

方法体也可以直接使用现成的其他类的方法：

public interface JDK8Interface {

    int method(int a);

}

class Test {

    public static void main(String[] args) {

        /**
         * 方法体也可以直接使用现成的其他类的方法
         */

        // 调用本类test类中已经存在的num()方法作为方法体
        JDK8Interface num = a -> num(a);
        System.out.println(num.method(5));

        // 静态方法：可以写成类名::方法名，相当于把Test::num作为方法体传入
        JDK8Interface num1 = Test::num;
        System.out.println(num1.method(4));

        // 普通方法：创建对象，调用对象的方法传入
        Test test = new Test();
        JDK8Interface num2 = test::sum;
        System.out.println(num2.method(5));

    }

    public static int num(int b) {
        return b * 2;
    }

    public int sum(int c) {
        return c + 2;
    }

}

线程lambda的经典用法

// 线程lambda的经典用法
new Thread(() -> {
            System.out.println("线程lambda的经典用法");
        });
// 这段的意思就是，1:创建Runnable接口的实现类，并重写run()方法，并创建实现类的实例对象
() -> {System.out.println("线程lambda的经典用法");}

forEach经常用法

class Test {

    public static void main(String[] args) {

        // forEach
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        // 未用lambda表达式
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer o) {
                System.out.println(o);
            }
        });

        // 使用lambda表达式
        list.forEach(o -> System.out.println(o));
        list.forEach(System.out::println);
    }

}

删除集合中的某个元素

class Test {

    public static void main(String[] args) {

        // 删除集合中的某个元素
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
     
        // 使用lambda表达式
        list.removeIf(a -> a == 1);

    }

}

集合内元素的排序

class Test {

    public static void main(String[] args) {

        // 删除集合中的某个元素
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        // 使用lambda表达式
        list.sort((a, b) -> a - b);

    }

}

Lambda 表达式中的闭包问题

这个问题我们在匿名内部类中也会存在，在lambda表达式中操作的外部变量，在编译期间虚拟机会帮我们给变量加上 final 修饰关键字，所以不能改变外部变量的值。