JDK1.8新特性

2020-12-21  本文已影响0人  凌晨的咸鱼
  1. 接口增强,允许接口定义静态方法 和 默认方法
public interface JDK8Interface {

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

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

}
  1. 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 修饰关键字,所以不能改变外部变量的值。

上一篇下一篇

猜你喜欢

热点阅读