Java Stream进阶：按嵌套字段高效分组的实践指南

public class Project {
    private int id;
    private String name;

    public Project(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

public class Task {
    private String taskId;
    private String description;
    private Project project;

    public Task(String taskId, String description, Project project) {
        this.taskId = taskId;
        this.description = description;
        this.project = project;
    }

    public String getTaskId() {
        return taskId;
    }

    public String getDescription() {
        return description;
    }

    public Project getProject() {
        return project;
    }

    @Override
    public String toString() {
        return "Task{" + "taskId='" + taskId + '\'' + ", description='" + description + '\'' + ", project=" + project + '}';
    }
}

// 这是一个语法错误，无法编译
// tasks.stream().collect(Collectors.groupingBy(task::getProject::getId));

task -> task.getProject().getId()

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GroupByNestedFieldExample {

    public static void main(String[] args) {
        // 准备数据
        Project projectA = new Project(101, "Project Alpha");
        Project projectB = new Project(102, "Project Beta");
        Project projectC = new Project(103, "Project Gamma");

        List<Task> tasks = Arrays.asList(
                new Task("T001", "Develop Feature X", projectA),
                new Task("T002", "Fix Bug Y", projectB),
                new Task("T003", "Write Documentation", projectA),
                new Task("T004", "Deploy Service Z", projectC),
                new Task("T005", "Test Module M", projectB),
                new Task("T006", "Refactor Codebase", projectA)
        );

        System.out.println("原始任务列表:");
        tasks.forEach(System.out::println);
        System.out.println("\n---");

        // 使用Lambda表达式按嵌套字段Project的ID进行分组
        Map<Integer, List<Task>> tasksByProjectId = tasks.stream()
                .collect(Collectors.groupingBy(task -> task.getProject().getId()));

        System.out.println("按Project ID分组后的任务:");
        tasksByProjectId.forEach((projectId, taskList) -> {
            System.out.println("Project ID: " + projectId);
            taskList.forEach(task -> System.out.println("  " + task.getTaskId() + ": " + task.getDescription()));
        });

        // 验证结果（可选）
        System.out.println("\n--- 验证结果 ---");
        System.out.println("Project A (ID 101) 的任务数量: " + tasksByProjectId.get(101).size()); // 期望3
        System.out.println("Project B (ID 102) 的任务数量: " + tasksByProjectId.get(102).size()); // 期望2
        System.out.println("Project C (ID 103) 的任务数量: " + tasksByProjectId.get(103).size()); // 期望1
    }
}

原始任务列表:
Task{taskId='T001', description='Develop Feature X', project=Project{id=101, name='Project Alpha'}}
Task{taskId='T002', description='Fix Bug Y', project=Project{id=102, name='Project Beta'}}
Task{taskId='T003', description='Write Documentation', project=Project{id=101, name='Project Alpha'}}
Task{taskId='T004', description='Deploy Service Z', project=Project{id=103, name='Project Gamma'}}
Task{taskId='T005', description='Test Module M', project=Project{id=102, name='Project Beta'}}
Task{taskId='T006', description='Refactor Codebase', project=Project{id=101, name='Project Alpha'}}

---
按Project ID分组后的任务:
Project ID: 101
  T001: Develop Feature X
  T003: Write Documentation
  T006: Refactor Codebase
Project ID: 102
  T002: Fix Bug Y
  T005: Test Module M
Project ID: 103
  T004: Deploy Service Z

--- 验证结果 ---
Project A (ID 101) 的任务数量: 3
Project B (ID 102) 的任务数量: 2
Project C (ID 103) 的任务数量: 1

// 假设我们有一个Task实例
Task someTask = new Task("T007", "New Task", new Project(999, "Ad-hoc Project"));

// 我们可以先获取到Project对象
Project projectInstance = someTask.getProject();

// 然后，可以为这个特定的Project实例创建一个方法引用
// 这里的 Function<Task, Integer> 只是为了演示类型兼容性，
// 实际使用时，keyExtractor 期待的是 Function<T, K>，这里的 T 是 Task
// 但如果直接定义 Function<Project, Integer>，则可以这样写：
java.util.function.Function<Project, Integer> projectToId = projectInstance::getId;

// 此时，projectToId.apply(projectInstance) 将返回 999
// 但这并不适用于 Stream 的 keyExtractor，因为 Stream 中的每个元素都是独立的 Task 对象，
// 我们没有预先持有每个 Task 内部 Project 对象的引用。