寻求更简洁的HashMap<String[], Boolean>按String[]元素升序排序方案

Hey there! Let's break down how to sort your HashMap<String[], Boolean> more cleanly, and fix that TreeMap issue you ran into.

First, A Quick Note on Your Current Approach #

Your existing code gets the job done, but it has a couple of potential pitfalls:

• If the str[0] values aren't consecutive integers starting from 0, calling arrayList.set(index, str) will throw an IndexOutOfBoundsException.
• Initializing an ArrayList with empty arrays first is unnecessary and adds extra clutter.

Why TreeMap Didn't Work (And How to Fix It) #

TreeMap relies on either the natural ordering of its keys or a custom comparator you define. Since String[] doesn't have a built-in natural ordering that compares the first element of the array, the default TreeMap was just comparing array references (which isn't what you want at all).

To make TreeMap work correctly, you just need to pass a custom comparator that sorts by the first element of the String[] key:

// Create TreeMap with a custom comparator to sort by the first element of the String array
TreeMap<String[], Boolean> sortedLiteralTable = new TreeMap<>(Comparator.comparing(arr -> arr[0]));

// Copy all entries from your original HashMap into the TreeMap
sortedLiteralTable.putAll(literalTable);

Now the TreeMap will automatically keep your entries in ascending order based on arr[0] of the keys, no extra sorting steps needed.

Simpler Alternatives to Sort the HashMap #

1. Directly Sort the Entry Set as a List #

Instead of messing with indexes, you can convert the HashMap's entry set to a list and sort it directly:

// Convert the HashMap's entry set to a list
List<Map.Entry<String[], Boolean>> entryList = new ArrayList<>(literalTable.entrySet());

// Sort the list by the first element of the String array key
entryList.sort(Comparator.comparing(entry -> entry.getKey()[0]));

If you need a sorted map afterward, just dump the sorted entries into a LinkedHashMap to preserve the order:

LinkedHashMap<String[], Boolean> sortedMap = new LinkedHashMap<>();
for (Map.Entry<String[], Boolean> entry : entryList) {
    sortedMap.put(entry.getKey(), entry.getValue());
}

2. Use Stream API for a Clean One-Liner (Java 8+) #

The Stream API makes this even more concise:

LinkedHashMap<String[], Boolean> sortedMap = literalTable.entrySet()
    .stream()
    .sorted(Comparator.comparing(entry -> entry.getKey()[0]))
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (oldVal, newVal) -> oldVal, // Handle duplicate keys (adjust if needed)
        LinkedHashMap::new // Preserve the sorted order
    ));

Key Takeaways #

• TreeMap works perfectly if you provide the right comparator (don't rely on default array ordering).
• Converting to a list and sorting (or using Streams) is more flexible if you don't need a map that stays sorted as you add entries.
• Avoid index-based list initialization unless you're 100% sure your keys have consecutive, zero-starting integer values.

内容的提问来源于stack exchange，提问作者Ajay Kumar