一、Arrays 工具类（数组操作神器）

java.util.Arrays 是操作数组的工具类，提供了排序、查找、拷贝、转换等静态方法，简化数组操作。

1. 核心常用方法

方法	功能	示例
static String toString(Object[] a)	数组转字符串	Arrays.toString(new int[]{1,2,3}) → "[1, 2, 3]"
static void sort(int[] a)	对数组进行自然排序	Arrays.sort(arr);
static void sort(T[] a, Comparator<? super T> c)	自定义规则排序	Arrays.sort(students, (s1, s2) -> s1.getAge() - s2.getAge());
static int binarySearch(int[] a, int key)	二分查找（需先排序）	Arrays.binarySearch(arr, 2);
static int[] copyOf(int[] original, int newLength)	拷贝数组（可扩容 / 缩容）	int[] newArr = Arrays.copyOf(arr, 5);
static boolean equals(int[] a, int[] a2)	比较两个数组内容是否相同	Arrays.equals(arr1, arr2);

2. 示例：基础类型数组操作

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {10, 20, 5, 30, 15};
        
        // 排序
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
        
        // 二分查找（需先排序）
        int index = Arrays.binarySearch(arr, 20);
        System.out.println("20的索引：" + index);
        
        // 数组拷贝
        int[] newArr = Arrays.copyOf(arr, 7);
        System.out.println("拷贝后：" + Arrays.toString(newArr));
    }
}

3. 示例：对象数组自定义排序

对象数组排序需实现比较逻辑，有两种方式：

方式 1：实现 Comparable 接口（自然排序）

// 学生类实现Comparable接口
public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double height;
​
    // 构造方法、getter/setter、toString
​
    // 重写compareTo方法，定义排序规则
    @Override
    public int compareTo(Student o) {
        // 按年龄升序排序
        return this.age - o.age;
        // 按身高降序排序
        // return Double.compare(o.height, this.height);
    }
}
​
// 使用
Student[] students = {new Student("张三", 20, 175), new Student("李四", 18, 180)};
Arrays.sort(students); // 按年龄升序

方式 2：使用 Comparator 比较器（临时排序规则）

Student[] students = {new Student("张三", 20, 175), new Student("李四", 18, 180)};
​
// 按身高降序排序（匿名内部类方式）
Arrays.sort(students, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return Double.compare(o2.getHeight(), o1.getHeight());
    }
});
​
// Lambda表达式简化
Arrays.sort(students, (o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()));

---

二、Lambda 表达式（函数式编程入门）

Lambda 表达式是 JDK 8 引入的新特性，用于简化函数式接口（仅含一个抽象方法的接口）的实现，让代码更简洁。

1. 核心概念

• 函数式接口：只有一个抽象方法的接口（可用 @FunctionalInterface 注解标识）。

• Lambda 语法：(参数列表) -> {方法体}

• 简化规则：

  1. 参数类型可省略（编译器自动推断）。

  2. 只有一个参数时，小括号可省略。

  3. 方法体只有一条语句时，大括号、return 关键字可省略。

2. 常见景示例

（1）无参无返回值

// 函数式接口
@FunctionalInterface
public interface SendMessage {
    void send();
}
​
// Lambda实现
SendMessage sm = () -> System.out.println("发送消息");
sm.send();

（2）带参无返回值

@FunctionalInterface
public interface SendMessage {
    void send(String name, String type);
}
​
// Lambda实现
SendMessage sm = (name, type) -> System.out.println(name + "发送" + type + "消息");
sm.send("张三", "邮件");

（3）带参有返回值

@FunctionalInterface
public interface Addable {
    int add(int a, int b);
}
​
// Lambda实现
Addable add = (a, b) -> a + b;
System.out.println(add.add(5, 3)); // 输出8

3. 简化过程对比

// 匿名内部类方式
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("线程执行");
    }
};
​
// Lambda简化（无参无返回值）
Runnable runnable = () -> System.out.println("线程执行");

---

三、Stream 流（集合 / 数组的流式操作）

Stream 是 JDK 8 引入的流式数据处理 API，支持对集合、数组进行过滤、映射、排序、聚合等操作，让数据处理更简洁高效。

1. 核心步骤

1. 获取流：从集合 / 数组获取 Stream 对象。

2. 中间操作：对流中的数据进行处理（过滤、映射、排序等），返回新的 Stream。

3. 终结操作：触发计算，关闭流（如 forEach、collect）。

2. 获取流的方式

// 1. 集合获取流
List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream();
​
// 2. 数组获取流
String[] arr = {"apple", "banana", "orange"};
Stream<String> stream = Arrays.stream(arr);

3. 常用中间操作

方法	功能	示例
filter(Predicate<T> predicate)	过滤元素	stream.filter(s -> s.startsWith("a"))
map(Function<T, R> mapper)	映射转换	stream.map(String::toUpperCase)
sorted()	自然排序	stream.sorted()
distinct()	去重	stream.distinct()
limit(long maxSize)	限制元素数量	stream.limit(3)
skip(long n)	跳过前 n 个元素	stream.skip(1)

4. 常用终结操作

方法	功能	示例
forEach(Consumer<T> action)	遍历元素	stream.forEach(System.out::println)
collect(Collectors.toList())	收集为 List	stream.collect(Collectors.toList())
count()	统计元素个数	stream.count()
max(Comparator<T> comparator)	获取最大值	stream.max(Comparator.naturalOrder())
min(Comparator<T> comparator)	获取最小值	stream.min(Comparator.naturalOrder())

5. 示例：综合数据处理

List<Student> students = Arrays.asList(
    new Student("张三", 20, 175),
    new Student("李四", 18, 180),
    new Student("王五", 22, 170)
);
​
// 过滤年龄大于18岁的学生，按身高降序排序，收集姓名
List<String> names = students.stream()
    .filter(s -> s.getAge() > 18)
    .sorted((s1, s2) -> Double.compare(s2.getHeight(), s1.getHeight()))
    .map(Student::getName)
    .collect(Collectors.toList());
​
System.out.println(names); // 输出：[张三, 王五]

---

四、方法引用（Method Reference）

方法引用是 Lambda 表达式的简化形式，用于直接引用已有的方法（静态方法、实例方法、构造方法），进一步简化代码。

1. 常见类型

类型	语法	适用场景	示例
静态方法引用	类名::静态方法	引用类的静态方法	Integer::parseInt
实例方法引用	对象::实例方法	引用对象的实例方法	System.out::println
特定类型实例方法引用	类名::实例方法	引用类的实例方法，第一个参数为调用对象	String::compareTo
构造方法引用	类名::new	引用类的构造方法	Student::new

2. 示例：方法引用简化

// Lambda方式
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(s -> System.out.println(s));
​
// 方法引用简化（实例方法引用）
list.forEach(System.out::println);
​
// 静态方法引用
Function<String, Integer> func = Integer::parseInt;
int num = func.apply("123");
​
// 构造方法引用
Supplier<Student> supplier = Student::new;
Student student = supplier.get();

---

五、核心记忆要点

1. Arrays 工具类：

   • 基础类型数组直接 sort()，对象数组需实现 Comparable 或传入 Comparator。

   • binarySearch 需先排序，否则结果不可预测。

2. Lambda 表达式：

   • 只能用于函数式接口（仅一个抽象方法）。

   • 简化规则：参数类型可省、单参括号可省、单行语句大括号 /return 可省。

3. Stream 流：

   • 中间操作返回新流，可链式调用；终结操作关闭流，流不可重复使用。

   • 数据处理三步：获取流 → 中间操作 → 终结操作。

4. 方法引用：

   • 是 Lambda 的简化形式，直接引用已有方法，代码更简洁。

   • 四种类型：静态方法、实例方法、特定类型实例方法、构造方法。