自定义比较器<String> java中的问题

Question

I am currently making a natural sorting algorithm in Java. And the requirement is to make it run fast. Given an input String list, [1!, 10!, 100, 100!, 2]. The expected output order is [1!, 2, 10!,100, 100!]. As you can see they sort digit number first and then compare the value. However it is giving me headache when designing the cases.

Here is my thoughts when designing this problem.

Given String a , b .
(Edit: The input values could be 100!90!10!1234 with multiple "!" inside.Sorry for not mentioning earlier.The input will have english letter as well. But current version could handle it like a boss)

I create four index (ind_a1, ind_a2, ind_b1, ind_b2)

Case 1: If either ind_a1 or ind_b1 touch ! , then return -1

Case 2: If either ind_a1 or ind_b1 touch the end of the string - 1 return -1 (The current problem occurs right here in Case 2)

Case 3: When both index touch ! ,

Case 3.1: Check if a.substring(ind_a2, ind_a1) == (b.substring(ind_b2, ind_b1) If they are equal means the previous values are the same. For example: 1258!100 and 1258!10 . a.substring(ind_a2, ind_a1) = (b.substring(ind_b2, ind_b1) = 1258

Case 3.2:If they are not equal, then it just returns the previous compare values.

Here is my full code.

public int compare(String a, String b) {
        int ind_a1 = 0 ,ind_a2 = 0;
        int ind_b1 = 0 ,ind_b2 = 0;
        int length_a = a.length();
        int length_b = b.length();
        int result = a.compareTo(b);
        char char_a, char_b;


        while(true)
        {
            char_a = a.charAt(ind_a1);
            char_b = b.charAt(ind_b1);
            //check if a or b is an empty String
            if(length_a == 0 || length_b ==0) {
                return length_a - length_b;
            }

            //Case 1）
            if(char_a == '!' && char_b != '!') {
                return -1;
            }
            if(char_b == '!' && char_a != '!') {
                return +1;
            }
            //Case 2: I NEED HELP HERE
            if(ind_a1 == length_a-1 || ind_b1 == length_b-1 ) {
                return length_a - length_b;
            }

            //Case 2 corner case, if both string has same length
            if(length_a == length_b) {
                return result;
            }

            //Case 3, if both index touch "!"   
            if(char_a =='!' && char_b == '!' ) {
                //Case 3.1
                if(a.substring(ind_a2, ind_a1) == (b.substring(ind_b2, ind_b1))) {
                    ind_a2 = ind_a1;
                    ind_b2 = ind_b1;
                }
                //Case 3.2
                else {
                    return a.substring(ind_a2,ind_a1).compareTo(b.substring(ind_b2,ind_b1));
                }                       
            }       
            ind_a1++;
            ind_b1++;
        }


    }

}

The current output order is [2, 1!, 10!, 100, 100!]. I know it doesnt work because 2 has less index then 1! so it will return -1. However is there anyway to adjust the code (or make it better, I would be so grateful) to make it work ?

(Example, Given input of [A5,a5,A5!,a5!,!A,!a,A,a,1,!]

The output should be [!, !A, !a, 1, A, a, A5, A5!, a5! ])

Answer 1

public static void main(String... S) {
    List a = Arrays.asList("1!", "10!", "100!", "100", "2");
    Collections.sort(a, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            int oo1 = 0;
            int oo2 = 0;

            if (o1.contains("!")) {
                oo1 = 1;
                o1 = o1.replace("!", "");
            }

            if (o2.contains("!")) {
                oo2 = 1;
                o2 = o2.replace("!", "");
            }

            int result = (Integer.valueOf(o1) - Integer.valueOf(o2));

            return result == 0 ? oo1 - oo2 : result;
        }
    });
    System.out.println(a);

}

As per comment

@Psingh We dont have to deal with "!!!!" scenario. The expected value should be [2, A, 1!, 10!, 100, 100! ]

public static void main(String... S) {
    List a = Arrays.asList("1!", "1!!", "10!", "100!", "100", "2", "A");
    Collections.sort(a, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            int ooo1 = 0;
            int ooo2 = 0;

            for (char i : o1.toCharArray()) {
                ooo1 += (int) i;
            }
            for (char i : o2.toCharArray()) {
                ooo2 += (int) i;
            }
            return ooo1 - ooo2;
        }
    });
    System.out.println(a);
}

Answer 2

Edit: Added the test case you mentioned before, to point out there inconsistency.

---

Give this a try. I am still not sure whether this covers all your input requirements, but works for the following testcases:

input: [A5,a5,A5!,a5!,!A,!a,A,a,1,!]
expected output: [!, !A, !a, 1, A, a, A5, a5, A5!, a5!]

input: [1!, 1!!, 10!, 100!, 100, 2, A]
expected output: [2, A, 1!, 1!!, 10!, 100, 100!]

However for this testcase:

input: [1!, 10!, 100, 100!, 2 , 2!, 22!, 22, 100 , 3]
expected output: [1!, 2, 2!, 3, 22, 22!, 100, 100!]

the output is different. You expectations seem to be inconsistent in this case, as this example has a different ordering for the elements 2 & 1!.

As long as that is the case there isnt really any point in trying to answer your question.

---

    Collections.sort(a, new Comparator<String>() {

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

            int minSize = Math.min(o1.length(), o2.length());
            int index = 0;

            while (index < minSize) {

                char c1 = o1.charAt(index);
                char c2 = o2.charAt(index);

                if (c1 != c2) {

                    if (o1.length() == o2.length()) {
                        return c1 - c2;
                    }

                    if (c1 == '!') {
                        return -1;
                    } else if (c2 == '!') {
                        return 1;
                    }

                    return o1.length() - o2.length();
                }

                index++;
            }

            if (o1.length() == index) {
                if (o2.length() == index) {
                    return 0;
                }

                return -1;
            } else {
                return 1;
            }
        }
    });