05_Arrays与Lambda

Arrays

// Arrays：基本使用

import java.util.Arrays;
import java.util.function.IntToDoubleFunction;

public class Test {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60};
        // 1. 返回数组的内容
        System.out.println(Arrays.toString(arr));  // [10, 20, 30, 40, 50, 60]

        // 2. 拷贝数组
        int[] arr2 = Arrays.copyOfRange(arr, 1, 4);
        System.out.println(Arrays.toString(arr2));  // [20, 30, 40]

        // 3. 拷贝数组，可以指定新数组的长度
        int[] arr3 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr3));  // [10, 20, 30, 40, 50, 60, 0, 0, 0, 0]

        // 4. 把数组中的原数据改为新数组又存进去
        double[] prices = {99.8, 128, 100};
        // 把所有的价格都打八折，然后又存进去
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                // value = 0 1 2 3...
                return prices[value] * 0.8;
            }
        });
        System.out.println(Arrays.toString(prices));  // [79.84, 102.4, 80.0]


        // 5. 对数组进行排序（默认是升序排序）
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));
    }
}

// Arrays：为对象进行排序

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

public class Test {
    public static void main(String[] args) {
        // 准备一些对象
        Student[] arr = new Student[4];
        arr[0] = new Student("Jack", 20);
        arr[1] = new Student("Peter", 16);
        arr[2] = new Student("Tony", 24);
        arr[3] = new Student("Wang", 10);

        // 实现：按照对象的年龄属性，进行降序排序
        Arrays.sort(arr, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 约定1：认为左边对象 大于 右边对象，返回正整数
                // 约定2：认为左边对象 小于 右边对象，返回负整数
                // 约定3：认为左边对象 等于 右边对象，返回0

//                return o1.getAge() - o2.getAge();  // 升序排序
                return o2.getAge() - o1.getAge();  // 降序排序
            }
        });

        // 展示结果
        System.out.println(Arrays.toString(arr));
        // [Student{name='Tony', age=24}, Student{name='Jack', age=20}, Student{name='Peter', age=16}, Student{name='Wang', age=10}]

    }
}

class Student {
    private String name;
    private int age;

    Student() {

    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + 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;
    }
}

Lambda

Lambda 表达式是 JDK 8 开始新增的一种语法格式；作用：用于简化匿名内部类的代码写法

• 注意：Lambda 表达式只能简化函数式接口的匿名内部类
• 什么是函数式接口：有且仅有一个抽象方法的接口
• 将来我们见到的大部分函数式接口，上面都可能有一个@FunctionalInterface的注解，有该注解的接口就必定是函数式接口

public class Test {
    public static void main(String[] args) {
        // 传统写法
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("狗跑的快！");
            }
        };
        a.run();  // 狗跑的快！

        // 注意：Lambda 表达式只能简化"函数式接口"的匿名内部类
//        Swimming obj = new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("能游泳");
//            }
//        };
        Swimming obj = () -> {
            System.out.println("能游泳");
        };
        obj.swim();  // 能游泳
    }
}

interface Swimming {
    void swim();
}

abstract class Animal {
    public abstract void run();
}

Lambda 表达式的省略写法（进一步简化 Lambda 表达式的写法）

• 参数类型可以省略不写
• 如果只有一个参数，参数类型可以省略，同时（）也可以省略
• 如果 Lambda 表达式中的方法体代码只有一行，可以省略大括号不写，同时也要省略分号！此时，如果这行代码是 return 语句，也必须去掉 return 不写

方法引用

JDK 8 新特性，其目的是为了进一步简化 Lambda 表达式

• 静态方法的引用

// 伪代码:

// 第一部分
public class CompareByData{
    // 静态方法
    public static int compareByAge(Student o1, Student o2){
        return o1.getAge() - o2.getAge();
    }
}

// 第二部分 (以下的三行代码是等价的，只是形式不同)
Arrays.sort(arr, (o1, o2) -> o1.getAge() - o2.getAge());  // Lambda 表达式
    
Arrays.sort(arr, (o1, o2) -> CompareByData.compareByAge(o1, o2))  // 结合第一部分
    
Arrays.sort(arr, CompareByData::compareByAge);  // 静态方法引用（为了简化）

• 实例方法的引用

// 伪代码:

// 第一部分
public class CompareByData{
    // 实例方法
    public int compareByAge(Student o1, Student o2){
        return o1.getAge() - o2.getAge();
    }
}

// 第二部分 (以下的三行代码是等价的，只是形式不同)
Arrays.sort(arr, (o1, o2) -> o1.getAge() - o2.getAge());  // Lambda 表达式
    
CompareByData compare = new CompareByData();  // 结合第一部分
Arrays.sort(arr, (o1, o2) -> compare.compareByAge(o1, o2));
    
Arrays.sort(arr, compare::compareByAge);  // 实例方法引用（为了简化）

• 特定类型方法的引用

// 伪代码:

// 原始代码
Arrays.sort(arr, new Comparator<String>(){
    @Override
    public int compare(String o1, String o2){
        return 01.compareToIgnoreCase(o2);
    }
});

// 使用 Lambda 表达式————优化之后
Arrays.sort(arr, (o1, o2) -> o1.compareToIgnoreCase(o2));

// 使用特定类型方法引用
Arrays.sort(arr, String::compareToIgnoreCase);

• 构造器引用

// 伪代码:

// 第一部分
public class Car{
    private String name;
    private double price;
    public Car(String name, double price){
        this.name = name;
        this.price = price;
    }
    ...
}

// 第二部分

// 原始代码
CreateCar cc = new CreateCar(){
    @Override
    public Car create(String name, double price){
        return new Car(name, price);
    }
};
cc.create("奔驰"，"58.8");

// 使用 Lambda 表达式进行化简
CreateCar cc = (name, price) -> new Car(name, price);

// 构造器引用
CreateCar cc = Car::new;