05_使用API_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;