Java进阶13讲__第五讲

最新推荐文章于 2024-11-12 21:14:07 发布

不再会有谎言

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量362

点赞数 7

分类专栏： Java进阶13讲文章标签： java python 开发语言

本文链接：https://blog.csdn.net/xiaomeiguisnjs/article/details/141334752

版权

Java进阶13讲专栏收录该内容

23 篇文章 0 订阅

订阅专栏

JDK8新特性-Lambda

1.认识Lambda

2.Lambda表达式的省略写法

进一步简化Lambda表达式的写法

package cn.hdc.oop5.lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Test2 {
    public static void main(String[] args) {
        double[] price = {99.8, 128, 100};
//        Arrays.setAll(price, (int value) -> {
//            return price[value] * 0.8;
//        });
        /**
         * 参数类型可以省略不写
         * 如果只有一个参数，参数类型可以省略同时()也可以省略
         */
//        Arrays.setAll(price, value -> {
//            return price[value] * 0.8;
//        });
        /**
         * 如果Lambda表达式中的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号!此时，如
         * 果这行代码是return语句，也必须去掉return不写，
         */
        Arrays.setAll(price, value -> price[value] * 0.8);
        System.out.println("-------------------------------------------------------");
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精", 169.5, 23);
        students[1] = new Student("紫霞", 163.8, 26);
        students[2] = new Student("紫霞", 163.8, 26);
        students[3] = new Student("至尊宝", 167.5, 24);
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return (int) (o1.getHeight() - o2.getHeight());
//            }
//        });
//        Arrays.sort(students, (Student o1, Student o2) -> {
//            return Double.compare(o1.getHeight(), o2.getHeight());
//        });
//        Arrays.sort(students, (o1, o2) -> {
//            return Double.compare(o1.getHeight(), o2.getHeight());
//        });
        Arrays.sort(students, (o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
    }
}

class Student {
    private String name;
    private double height;
    private int age;

    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 double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }
}

3.方法引用

Lambda表达式用来简化函数式接口的匿名内部类
方法引用进一步简化Lambda表达式
方法引用的标志性符号：“ :: ”

1.静态方法的引用

package cn.hdc.oop5.staticMethod;

import cn.hdc.oop5.lambda.Student;

import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精", 169.5, 23);
        students[1] = new Student("紫霞", 163.8, 26);
        students[2] = new Student("紫霞", 163.8, 26);
        students[3] = new Student("至尊宝", 167.5, 24);
        Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
        Arrays.sort(students, (o1, o2) -> CompareByData.compareByAge(o1, o2));
        /**
         * 如果某个Lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用。
         */
        Arrays.sort(students, CompareByData::compareByAge);
    }
}

package cn.hdc.oop5.staticMethod;

import cn.hdc.oop5.lambda.Student;

public class CompareByData {
    public static int compareByAge(Student s1, Student s2) {
        return s1.getAge() - s2.getAge();
    }
}

2.实例方法的引用

package cn.hdc.oop5.staticMethod;

import cn.hdc.oop5.lambda.Student;

import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精", 169.5, 23);
        students[1] = new Student("紫霞", 163.8, 26);
        students[2] = new Student("紫霞", 163.8, 26);
        students[3] = new Student("至尊宝", 167.5, 24);
        Arrays.sort(students, (o1, o2) -> new CompareByData().compareByHeight(o1, o2));
        /**
         * 如果某个Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用
         */
        Arrays.sort(students, new CompareByData()::compareByHeight);
    }
}

package cn.hdc.oop5.staticMethod;

import cn.hdc.oop5.lambda.Student;

public class CompareByData {
    public int compareByHeight(Student s1, Student s2) {
        return (int) (s1.getHeight() - s2.getHeight());
    }
}

3.特定类型方法的引用

package cn.hdc.oop5.special;

import java.util.Arrays;
import java.util.Comparator;

public class specialImport {
    public static void main(String[] args) {
        String[] names = {"boby", "angela", "Andy", "dlei", "caocao", "Babo", "jack", "Cici"};
//        Arrays.sort(names);
//        Arrays.sort(names, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareToIgnoreCase(o2);
//            }
//        });
//        Arrays.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2));
        /**
         * 如果某个Lambda表达式里只是调用一个实例方法，
         * 并且前面参数列表中的第一个参数是作为方法的主调
         * 后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。
         */
        Arrays.sort(names, String::compareToIgnoreCase);
        System.out.println(Arrays.toString(names));
    }
}

4.构造器的引用

package cn.hdc.oop5.constructor;

public class constructorImport {
    public static void main(String[] args) {
//        CreateCar cc = new CreateCar() {
//            @Override
//            public Car create(String name, double price) {
//                return new Car(name, price);
//            }
//        };
//        CreateCar cc = (name, price) -> new Car(name, price);
        /**
         * 如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用
         */
        CreateCar cc = Car::new;//构造器引用
        Car C = cc.create("BMW", 49.9);
        System.out.println(C);
    }
}

interface CreateCar {
    Car create(String name, double price);
}

package cn.hdc.oop5.constructor;

public class Car {
    private String name;
    private double price;

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public Car() {
    }

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}