JDK8新特性

最新推荐文章于 2024-09-30 16:09:20 发布

hppaizr

最新推荐文章于 2024-09-30 16:09:20 发布

阅读量378

点赞数 4

分类专栏： java 文章标签： java jdk

本文链接：https://blog.csdn.net/hppaizr/article/details/133748100

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、jdk8包括哪些新特性

二、Lambda表达式

（一）Lambda表达式是JDK8新增的一种语法形式

一、jdk8包括哪些新特性

Lambda表达式
方法引用

静态方法的引用
实例方法的引用
特定类型方法的引用
构造器引用

二、Lambda表达式

（一）Lambda表达式是JDK8新增的一种语法形式

作用：用于简化函数式接口的匿名内部类

（二）什么是函数式接口？

有且仅有一个抽象方法的接口
注意：大部分的函数式接口都有一个@FunctionalInterface注解，有该注解必定是函数式接口

（三）格式

(被重写方法的形参列表)->{

        被重写方法的方法体代码

}

（四）示例

@FunctionalInterface //声明是函数式接口
public interface Animal {
    public String run(String name);
}

/**
 * lambda表达式是用于简化实现函数式接口的匿名内部类
 */
public class lambda {
    public static void main(String[] args) {
        //1.匿名内部类写法
        Animal animal = new Animal() {
            @Override
            public String run(String name) {
                return name + "在跑步";
            }
        };
        System.out.println(animal.run("小明"));
        //2.lambda表达式简化
        Animal animal2 = (String name)->{
            return name + "在跑步";
        };
        /**
         * lambda表达式简写规则
         * 1.参数类型可以不写
         * 2.一个参数不需要带括号 无参和多参必须声明括号()
         * 3.如果参数只有一个，参数类型可以省略，同时()也可以省略
         * 4.如果lambda表达式中方法体只有一行代码，可以省略花括号，同时要省略分号！
         * 此时如果这行代码是return语句，return也必须去掉不写
         */
        Animal animal3 = name -> name + "在跑步";

    }
}

三、方法引用

作用：用于简化lambda表达式

（一）静态方法引用

使用方式

类名::静态方法

使用场景

当lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用

（二）实例方法引用

使用方式

对象名::实例方法

使用场景

当lambda表达式只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用

（三）特定类型方法引用

使用方式

类型名::方法

使用场景

如果某个lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参，则此时就可以使用特定类型的方法引用

（四）构造方法引用

使用方式

类名::new

使用场景

如果某个lambda表达式只是在创建对象，并且前后参数情况一致，就可以使用构造器引用

（五）示例

用于演示的静态方法引用、实例方法引用的自定义类：Student和CompareByAge

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class CompareByAge {
    public static int compareByAge(Student o1,Student o2){
        return o1.getAge() - o2.getAge();
    }

    public int compareByAgeDESC(Student o1,Student o2){
        return o2.getAge() - o1.getAge();
    }
}

2.用于演示构造器引用的自定义接口：CreteStudent

@FunctionalInterface
public interface CreteStudent {
    public Student createStudent(String name,int age);
}

public class MethodUse {

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("张三", 19);
        students[1] = new Student("李四", 17);
        students[2] = new Student("王五", 21);
        //1.匿名内部类写法
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        //2.lambda表达式写法
        Arrays.sort(students, ((o1, o2) -> o1.getAge() - o2.getAge()));
        //3.静态方法引用
        //lambda去调用自定义类CompareByAge的compareByAge静态方法
        Arrays.sort(students, ((o1, o2) -> CompareByAge.compareByAge(o1, o2)));
        //使用方法引用改写
        //当lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用
        Arrays.sort(students, CompareByAge::compareByAge);

        //4.实例方法引用
        CompareByAge compare = new CompareByAge();
        Arrays.sort(students, (o1, o2) -> compare.compareByAgeDESC(o1, o2));
        //使用方法引用改写
        //当lambda表达式只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用
        Arrays.sort(students, compare::compareByAgeDESC);

        //5.特定类型的方法引用
        //如果某个lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面
        //的所有参数都是作为该实例方法的入参，则此时就可以使用特定类型的方法引用
        String[] names = {"boby", "angela", "Andy", "dlei", "caocao", "Babo", "jack", "Cici"};
        //进行排序（默认是按照字符串的首字符编号进行升序排序
        Arrays.sort(names);
        System.out.println(Arrays.toString(names));

        //要求忽略首字符大小写进行排序
        //1.匿名内部类
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareToIgnoreCase(o2);
            }
        });
        //2.lambda表达式
        Arrays.sort(names, ((o1, o2) -> o1.compareToIgnoreCase(o2)));
        //3.特定类型方法引用
        Arrays.sort(names, String::compareToIgnoreCase);


        //6.构造器引用
        //1.匿名内部类
        CreteStudent cs = new CreteStudent() {
            @Override
            public Student createStudent(String name, int age) {
                return new Student(name, age);
            }
        };
        //2.lambda表达式
        CreteStudent cs2 = ((name, age) -> new Student(name,age));
        //3.构造方法引用
        //如果某个lambda表达式只是在创建对象，并且前后参数情况一致，就可以使用构造器引用
        CreteStudent cs3 = Student::new;
    }
}