Java 比較排序與 Hash 映射實戰：Comparable、Comparator、Collections.sort、HashMap 核心用法全解析

Java 比較排序與 Hash 映射實戰：Comparable、Comparator、Collections.sort、HashMap 核心用法全解析

一、Comparable 自然排序

實現 Comparable<T> 接口，重寫 compareTo(T o) 定義「自然順序」。

public class Product implements Comparable<Product> {
    private String name;
    private double price;
    private String color;

    public Product(String name, double price, String color) {
        this.name = name; this.price = price; this.color = color;
    }

    @Override
    public int compareTo(Product other) {
        // 按價格升序
        return Double.compare(this.price, other.price);
    }

    @Override public String toString() {
        return "Product{name='" + name + "', price=" + price + ", color='" + color + "'}";
    }
}

使用 Arrays.sort / Collections.sort

Product[] products = {
    new Product("筆記本", 8.5, "red"),
    new Product("A4紙", 25.8, "white"),
    new Product("鉛筆", 1.2, "black")
};

Arrays.sort(products); // 升序
System.out.println("升序: " + Arrays.toString(products));
// 輸出: [鉛筆(1.2), 筆記本(8.5), A4紙(25.8)]

Arrays.sort(products, Collections.reverseOrder()); // 降序
System.out.println("降序: " + Arrays.toString(products));
// 輸出: [A4紙(25.8), 筆記本(8.5), 鉛筆(1.2)]

二、Comparator 定制排序 (策略模式)

不修改實體類，外部定義比較器，支持多維度排序。

// 按名稱長度降序
Comparator<Product> byNameLengthDesc = (p1, p2) ->
    Integer.compare(p2.getName().length(), p1.getName().length());

// 組合排序：先按價格升序，價格相同再按名稱升序
Comparator<Product> composite = Comparator
    .comparingDouble(Product::getPrice)
    .thenComparing(Product::getName);

Arrays.sort(products, composite);

三、HashMap 核心操作

Map<Integer, String> map = new HashMap<>();

map.put(1, "abc");
map.put(2, "123");
map.put(3, "823");
map.put(2, "qqq"); // 覆蓋 key=2 的值

// 遍歷方式 1: keySet
for (Integer key : map.keySet()) {
    System.out.println(key + " => " + map.get(key));
}

// 遍歷方式 2: entrySet (推薦，單次查找)
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " => " + entry.getValue());
}

// 遍歷方式 3: forEach (Java 8+)
map.forEach((k, v) -> System.out.println(k + " => " + v));

// 輸出 (順序不固定):
// 1 => abc
// 2 => qqq
// 3 => 823

四、HashMap 進階特性

五、常見面試題：比較器契約與陷阱

1. compareTo 與 equals 一致性：e1.compareTo(e2) == 0 應隱含 e1.equals(e2)，違反會導致 TreeSet/TreeMap 行為異常。
2. 傳遞性：a > b && b > c ⇒ a > c。
3. 對稱性：compare(a,b) == -compare(b,a)。
4. 避免減法溢出：return a - b 可能溢出，必須用 Integer.compare(a,b) 或 Long.compare。
5. 空指針安全：比較器內部處理 null (拋異常/視為最小/最大)。

六、實戰場景：電商商品多維排序

public class ProductService {
    public List<Product> sortProducts(List<Product> list, String sortBy, String order) {
        Comparator<Product> comparator = switch (sortBy) {
            case "price" -> Comparator.comparingDouble(Product::getPrice);
            case "name" -> Comparator.comparing(Product::getName);
            case "sales" -> Comparator.comparingLong(Product::getSales);
            default -> Comparator.comparingDouble(Product::getPrice);
        };
        if ("desc".equalsIgnoreCase(order)) comparator = comparator.reversed();
        return list.stream().sorted(comparator).collect(Collectors.toList());
    }
}

總結

• Comparable：定義自然順序，內部實現，Arrays.sort 直接用。
• Comparator：外部定制，多策略共存，Comparator.comparing... 鏈式組合極其強大。
• HashMap：O(1) 存取，鍵唯一，掌握 put/get/entrySet、擴容、線程安全替代品。
• 最佳實踐：優先用 Lambda/方法引用簡化比較器，組合排序用 thenComparing，遍歷用 entrySet 或 forEach。