只是想按长度排序，TreeMap 为什么把不同名字合成了一条？

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class Main {
    private static int checks;
    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }
    public static void main(String[] args) {
        Comparator<String> lengthOnly = Comparator.comparingInt(String::length);
        TreeMap<String, Integer> byLength = new TreeMap<>(lengthOnly);
        check(byLength.put("aa", 10) == null, "first key");
        Integer previous = byLength.put("bb", 20);
        check(previous == 10 && byLength.size() == 1, "zero comparison replaces value");
        check(!"aa".equals("bb") && lengthOnly.compare("aa", "bb") == 0, "two equalities differ");
        check(byLength.get("zz") == 20 && byLength.containsKey("zz"), "lookup uses same comparator");
        System.out.println("length-only: size=" + byLength.size() + " previous=" + previous
                + " get(zz)=" + byLength.get("zz") + " contains(zz)=" + byLength.containsKey("zz"));
        check(byLength.remove("zz") == 20 && byLength.isEmpty(), "remove uses same comparator");
        System.out.println("remove(zz): empty=" + byLength.isEmpty());

        Comparator<String> lengthThenText = lengthOnly.thenComparing(Comparator.naturalOrder());
        TreeMap<String, Integer> distinct = new TreeMap<>(lengthThenText);
        for (String key : List.of("bb", "c", "aa")) distinct.put(key, key.length());
        check(new ArrayList<>(distinct.keySet()).equals(List.of("c", "aa", "bb")), "tie-break order");
        check(!distinct.containsKey("zz") && distinct.size() == 3, "full text distinguishes keys");
        System.out.println("length-then-text: keys=" + distinct.keySet() + " contains(zz)=" + distinct.containsKey("zz"));

        List<String> words = new ArrayList<>(List.of("bb", "aa", "c"));
        words.sort(lengthOnly);
        check(words.equals(List.of("c", "bb", "aa")), "list sort retains tied items");
        System.out.println("list-sort: " + words + "; size=" + words.size());

        BigDecimal first = new BigDecimal("2.0"), second = new BigDecimal("2.00");
        Map<BigDecimal, String> hash = new HashMap<>();
        Map<BigDecimal, String> tree = new TreeMap<>();
        hash.put(first, "first"); hash.put(second, "second");
        tree.put(first, "first"); tree.put(second, "second");
        check(!first.equals(second) && first.compareTo(second) == 0, "decimal equality");
        check(hash.size() == 2 && tree.size() == 1, "different map key rules");
        check(tree.get(new BigDecimal("2.000")).equals("second"), "decimal lookup");
        System.out.println("decimal: equals=" + first.equals(second) + " compareTo=" + first.compareTo(second)
                + " hash-size=" + hash.size() + " tree-size=" + tree.size());

        List<String> corpus = List.of("", "a", "b", "aa", "bb", "aaa");
        for (String a : corpus) for (String b : corpus) {
            check((lengthThenText.compare(a, b) == 0) == a.equals(b), "equality consistency");
            check(Integer.signum(lengthThenText.compare(a, b)) == -Integer.signum(lengthThenText.compare(b, a)),
                    "comparison sign symmetry");
        }
        System.out.println("PASS " + checks + " checks; fixed keys, no concurrency or performance claim");
    }
}