Java 中 List B 根据 List A 的 sort 和 code 排序

java List A 里面的数据对象有code 和sort属性，List B里面有code 、name、recipe等属性。List B 实现先按照sort排序，再按照code排序。

# Java 中 List B 根据 List A 的 sort 和 code 排序

## 思路

1. 将 **List A** 转为 `Map<code, sort>`，方便快速查找。
2. 对 **List B** 排序时，先通过 `code` 去 Map 中取 `sort` 值进行排序，再按 `code` 排序。

## 完整代码示例

```java
import java.util.*;
import java.util.stream.Collectors;

public class SortExample {

    // List A 的对象
    static class ItemA {
        private String code;
        private Integer sort;

        public ItemA(String code, Integer sort) {
            this.code = code;
            this.sort = sort;
        }

        public String getCode() { return code; }
        public Integer getSort() { return sort; }
    }

    // List B 的对象
    static class ItemB {
        private String code;
        private String name;
        private String recipe;

        public ItemB(String code, String name, String recipe) {
            this.code = code;
            this.name = name;
            this.recipe = recipe;
        }

        public String getCode() { return code; }
        public String getName() { return name; }
        public String getRecipe() { return recipe; }

        @Override
        public String toString() {
            return "ItemB{code='" + code + "', name='" + name + "', recipe='" + recipe + "'}";
        }
    }

    public static void main(String[] args) {
        // 模拟 List A 数据
        List<ItemA> listA = Arrays.asList(
                new ItemA("C003", 2),
                new ItemA("C001", 1),
                new ItemA("C002", 1),
                new ItemA("C004", 3)
        );

        // 模拟 List B 数据
        List<ItemB> listB = new ArrayList<>(Arrays.asList(
                new ItemB("C003", "名称3", "配方3"),
                new ItemB("C001", "名称1", "配方1"),
                new ItemB("C002", "名称2", "配方2"),
                new ItemB("C004", "名称4", "配方4"),
                new ItemB("C002", "名称2-副本", "配方2-副本")
        ));

        // ==================== 核心逻辑 ====================

        // 第一步：将 List A 转为 Map<code, sort>
        Map<String, Integer> sortMap = listA.stream()
                .collect(Collectors.toMap(ItemA::getCode, ItemA::getSort, (v1, v2) -> v1));

        // 第二步：对 List B 排序
        listB.sort(
                // 先按 sort 排序（从 Map 中获取）
                Comparator.comparingInt(
                        (ItemB b) -> sortMap.getOrDefault(b.getCode(), Integer.MAX_VALUE)
                )
                // 再按 code 排序
                .thenComparing(ItemB::getCode)
        );

        // ==================== 输出结果 ====================
        listB.forEach(System.out::println);
    }
}
```

## 输出结果

```
ItemB{code='C001', name='名称1', recipe='配方1'}
ItemB{code='C002', name='名称2', recipe='配方2'}
ItemB{code='C002', name='名称2-副本', recipe='配方2-副本'}
ItemB{code='C003', name='名称3', recipe='配方3'}
ItemB{code='C004', name='名称4', recipe='配方4'}
```

> `C001` 和 `C002` 的 sort 都是 1，所以它们排在前面，且 `C001` < `C002`（按 code 二次排序）。

## 关键点说明

| 要点 | 说明 |
|------|------|
| **`Collectors.toMap`** | 将 List A 快速转为 `code → sort` 的映射，查找时间复杂度 O(1) |
| **`(v1, v2) -> v1`** | 处理 List A 中 code 重复的情况，保留第一个值 |
| **`getOrDefault(..., Integer.MAX_VALUE)`** | 如果 List B 中的 code 在 List A 中不存在，排到最后 |
| **`thenComparing`** | 实现"先按 sort，再按 code"的多级排序 |

如果 `sort` 可能为 `null`，可以改用 `Comparator.comparing()` 配合 `Comparator.nullsLast()` 来处理：

```java
listB.sort(
    Comparator.comparing(
        (ItemB b) -> sortMap.get(b.getCode()),
        Comparator.nullsLast(Comparator.naturalOrder())
    )
    .thenComparing(ItemB::getCode)
);
```