TreeSet无法使用自定义比较器正确排序

Question

I have a customized TreeSet:

    TreeSet<String> sortedOptionSet = new TreeSet<String> (new Comparator<String>() {

        @Override
        public int compare(String arg1, String arg2) {
            if (arg1 == null || arg2 == null) {
                return -1;
            }

            String o1 = arg1, o2 = arg2;
            String k1 = "1", k2 = "2";

            try{
                if (o1.contains("P1")) {
                    return -1;
                }
                else if (o2.contains("P1")) {
                    return 1;
                }
                else if (o1.contains("P2")) {
                    return -1;
                }
                else if (o2.contains("P2")) {
                    return 1;
                }
            } catch (Exception e) {}


            //If there is no rule for this combination, order them using key number ascending
            int result = 1;
            try {
                Integer key1 = Integer.valueOf(k1);
                Integer key2 = Integer.valueOf(k2);
                result = key1.compareTo(key2);
                if (result == 0) {
                    result = 1;
                }
            } catch (Exception e) {
            }
            return result;

        }
    });

    sortedOptionSet.add("TEST1");
    sortedOptionSet.add("P1");
    sortedOptionSet.add("TEST2");
    sortedOptionSet.add("P2");
    sortedOptionSet.add("TEST3");

    ArrayList<String> result = new ArrayList<String>();
    result.addAll(sortedOptionSet);

    for (String s : result) {
        System.out.println(s);
    }

I made the condition of P1 come first and thought the result should be:

P1
P2
TEST1
TEST2
TEST3

But the result returns

P2
P1
TEST1
TEST2
TEST3

I could not possible figure out why this is the behavior. Please help.

Answer 1

Your comparator violates many rules of the contract. In particular, a comparator is supposed to be consistent:

A > B iff B < A
A = B iff B = A
A > B and B > C ==> A > C

That's not the case. For example, if A and B are both null, compare(A, B) will lead to A < B, and compare(B, A) will lead to B < A.

Same if A and B both contain P1 or P2.

And if they have the same integer key, compare(A, B) will lead to A > B, and compare(B, A) will lead to B > A. Except in that case, you're not even comparing the arguments of the comparator, but two hard-coded values k1 and k2. And if there is an exception parsing any of the number, the first one is always the biggest one.