Java SE（一）内部类、Lambda表达式、Stream流

[1 内部类](#1 内部类)

匿名内部类（重点）

[2 Lambda表达式](#2 Lambda表达式)

Lambda表达式的省略规则

Lambda表达式的应用

[3 Stream流](#3 Stream流)

[3.1 Stream流的获取](#3.1 Stream流的获取)

[3.2 Stream 流的中间方法](#3.2 Stream 流的中间方法)

[3.3 Stream 流的终结方法](#3.3 Stream 流的终结方法)

[3.4 collect](#3.4 collect)

1 内部类

内部类的本质是：写在一个类里面的类。让一个类"只服务于另一个类"，并且可以直接访问外部类的成员。比如：汽车和引擎的关系，引擎只服务于汽车，不需要对外暴露。内部类适用于逻辑上强依赖的场景，避免类暴露和命名污染。

java 复制代码

public class Car {
    String carName;
    String carAge;

    // 成员内部类：引擎
    class Engine {
        String engineName;
        String engineAge;
    }
}

成员内部类 是写在成员位置的，属于外部类的成员。成员内部类可以被一些修饰符所修饰，比如：private，默认，protected，public，static（静态内部类 ）等。局部内部类是定义在方法里的局部内部类，这三种只是了解。

匿名内部类（重点）

隐藏了名字的内部类，没名字，只用一次，匿名内部类常用于回调和临时逻辑实现，创建完毕是匿名内部类的一个对象。

包含：①实现关系，②方法的重写，③创建对象。

格式：

new 类名/接口名(){

重写方法；

};

java 复制代码

public class Test {
    public static void main(String[] args) {
        Swim s = new Swim(){
            @Override
            public void swim() {
                System.out.println("匿名内部类：游泳");
            }
        };
        s.swim();
    }
}

2 Lambda表达式

函数式编程是一种思想特点，它忽略面向对象的复杂语法，强调做什么，而不是谁去做。Lambda表达式就是函数式编程思想的应用，格式如下：(形参)->{方法体}。

Lambda表达式可以用来简化函数式接口的匿名内部类的写法。

函数式接口：有且仅有一个抽象方法的接口。

java 复制代码

interface Swim {
    void swim();
}

Lambda表达式：

java 复制代码

public class Test {
    public static void main(String[] args) {
        Swim s = () -> {
            System.out.println("Lambda：游泳");
        };
        s.swim();
    }
}

Lambda表达式的省略规则

参数类型可以省略不写。
如果只有一个参数，参数类型可以省略，同时 () 也可以省略。
如果 Lambda 表达式的方法体只有一行，大括号，分号，return 可以省略不写，需要三个同时省略。

Lambda表达式的应用

排序：Arrays.sort(arr, (a, b) -> a - b);
集合遍历：list.forEach(e -> System.out.println(e));
条件过滤：list.stream().filter(x -> x > 10).forEach(System.out::println);
分组：Map<Long,List<Shop>> map = list.stream().collect(Collectors.groupingBy(Shop::getTypeId));
线程 / 回调：new Thread(() -> System.out.println("执行线程")).start();

匿名内部类 vs Lambda

Lambda 表达式是函数式接口的简写形式，用于替代匿名内部类，使代码更简洁。它通过类型推断和语法简化，可以省略参数类型、return 和大括号等。Lambda 常用于排序、集合遍历、Stream 操作和回调等场景。与匿名内部类相比，Lambda 更轻量，但只能用于函数式接口，并且 this 指向外部类。

3 Stream流

3.1 Stream流的获取

① 单列集合（Collection）

java 复制代码

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

② 双列集合（Map）

java 复制代码

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);

// 获取 key
map.keySet().stream();

// 获取 value
map.values().stream();

// 获取键值对（最常用）
map.entrySet().stream();

③ 数组

java 复制代码

int[] arr = {1, 2, 3};
Arrays.stream(arr);

④ 直接创建

java 复制代码

Stream.of(1, 2, 3);
Stream<String> stream = Stream.of("a", "b", "c");

3.2 Stream 流的中间方法

filter（过滤）、limit（截取前N个）、skip（跳过前N个）、distinct（去重）、concat（合并）、map（转换）、sorted（排序）

java 复制代码

list.stream().filter(x -> x > 10);
list.stream().limit(3);
list.stream().skip(3);
list.stream().distinct();
Stream.concat(stream1, stream2);
list.stream().map(x -> x * 2);
list.stream().sorted();
list.stream().sorted((o1, o2) -> o1 - o2);

3.3 Stream 流的终结方法

forEach（遍历）、count（统计）、toArrary（收集流中的数据放在数组中）、collect（收集流中的数据放在集合中）、max / min（最大最小）

java 复制代码

list.stream().forEach(System.out::println);
long count = list.stream().count();
Object[] arr = list.stream().toArray();
Integer[] arr = list.stream().toArray(Integer[]::new);
List<Integer> list = stream.collect(Collectors.toList());
Set<Integer> set = stream.collect(Collectors.toSet());
Optional<Integer> max = list.stream().max((o1, o2) -> o1 - o2);
Optional<Integer> min = list.stream().min((o1, o2) -> o1 - o2);

3.4 collect

作用：将流中的数据收集到集合或其他结构中。

① 收集到 List / Set

java 复制代码

List<Integer> list = stream.collect(Collectors.toList());
Set<Integer> set = stream.collect(Collectors.toSet());

② 收集到 Map

java 复制代码

Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(
        x -> x.getId(),     // key
        x -> x.getName()    // value
    ));

③ 分组

java 复制代码

Map<Long, List<Shop>> map = list.stream()
        .collect(Collectors.groupingBy(Shop::getTypeId));