使用命令CASE_INSENSITIVE_ORDER按键对TreeMap进行排序

Question

如何根据键在CASE_INSENSITIVE_ORDER对TreeMap<String, String>进行排序。

当前，默认情况下，其排序方式如下：

ABCD abcd

我希望它像：

a A b B c C d D

Answer 1

String.CASE_INSENSITIVE_ORDER比较器未按问题的要求排序。 要求的结果是一个类似的命令

a，a，b，B ...

相反，它将“ a”和“ A”视为“等于”，这意味着在排序映射中具有键“ a”的条目将覆盖具有键“ A”的条目。 根据上一次在地图上添加的内容，结果可能更像“ a，B”。

实现此行为的一种方法是使用类似这样的自定义比较器：

Comparator<String> comparator = new Comparator<String>() {

    public int compare(String s1, String s2) {
        int n1 = s1.length();
        int n2 = s2.length();
        int min = Math.min(n1, n2);
        for (int i = 0; i < min; i++) {
            char c1 = s1.charAt(i);
            char c2 = s2.charAt(i);
            if (c1 != c2) {
                if (isAtoZ(c1) && isAtoZ(c2)) {
                    return getSortPosition(c1) - getSortPosition(c2);
                }
                return c1 - c2;
            }
        }
        return n1 - n2;
    }


    private boolean isAtoZ(char c) {
        return c > 64 && c < 123;
    }

    private int getSortPosition(char c) {
        if (c < 91) {
            // upper case
            return 2 * (c - 64); // A = 2, B = 4 ...
        } else if (c > 96) {
            // lower case
            return (2 * (c - 96)) - 1; // a = 1, b = 3 ...
        } else {
            // between Z and a: [, /, ], ^, _, `
            return c; // higher than the value for 'z'
        }
    }

};

Answer 2

调用String＃CASE_INSENSITIVE_ORDER到TreeMap构造函数，

Map<String, String> tree = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);

Answer 3

您是否尝试过：

new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);

Answer 4

您可以将不区分大小写的顺序比较器作为TreeMap 构造函数之一的参数传递：

TreeMap<String, String> treemap = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);

Answer 5

在TreeMap构造函数中使用Comparator。 还有String.CASE_INSENSITIVE_ORDER 。

Answer 6

接受的答案是错误的-'a'和'A'是忽略大小写的相同键。 这里有一些玩具代码可以证明这一点，并提供可以回答问题的替代方案的草图。

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMapComparatorTest {
public static void main(String[] args) {
    TreeMap<String, Integer> caseInsensitive = new TreeMap<String, Integer>(String.CASE_INSENSITIVE_ORDER);
    caseInsensitive.put("a", 97);
    caseInsensitive.put("A", 65);

    // prints [a]
    System.out.println(caseInsensitive.keySet());

    TreeMap<String, Integer> customComparator = new TreeMap<String, Integer>(new Comparator<String>(){

        @Override
        public int compare(String o1, String o2) {

            // assuming only single letters for a smaller example...
            Character c1 = o1.charAt(0);
            Character c2 = o2.charAt(0);
            Character upper1 = Character.toUpperCase(c1);
            Character upper2 = Character.toUpperCase(c2);
            if(c1.compareTo(c2) == 0){

                // exactly the same char
                return 0;
            }else if (upper1.compareTo(upper2) == 0){

                // return lowercase first for same upper chars
                return -c1.compareTo(c2);
            }else{

                // order alphabetically
                return upper1.compareTo(upper2);
            }
        }
    });
    customComparator.put("a", 97);
    customComparator.put("A", 65);
    customComparator.put("b", 98);
    customComparator.put("B", 66);

    // prints [a, A, b, B]
    System.out.println(customComparator.keySet());
}

}