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

Question

我目前正在用Java制作一种自然排序算法。要求是使其运行快速。 给定一个输入字符串列表，[1！， 10！， 100， 100！， 2]。预期的输出顺序是 [1！， 2， 10！，100， 100！]。如您所见，他们首先对数字进行排序，然后比较值。然而，在设计案例时，这让我头疼。

这是我在设计这个问题时的想法。

给定字符串a，b。
(编辑：输入值可以是100！90！10！1234，里面有多个"！"。很抱歉没有早点提到。输入也将有英文字母。但是当前版本可以像老板一样处理它)

我创建四个索引(ind_a1, ind_a2, ind_b1, ind_b2)

情况 1：如果ind_a1或ind_b1触摸!，则返回-1

情况 2：如果ind_a1或ind_b1触摸字符串的末尾 - 1 返回-1(当前问题就发生在案例 2 中)

情况3：当两个索引触摸!时，

案例3.1： 检查是否a.substring(ind_a2, ind_a1) == (b.substring(ind_b2, ind_b1)如果它们相等，则表示以前的值相同。例如：1258!100和1258!10.a.substring(ind_a2, ind_a1) = (b.substring(ind_b2, ind_b1) = 1258

案例 3.2：如果它们不相等，则只返回之前的比较值。

这是我的完整代码。

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++;
}

}
}

当前输出顺序为 [2， 1！， 10！， 100， 100！]。我知道它不起作用，因为 2 的索引比 1 少！所以它将返回 -1。但是，无论如何都可以调整代码(或使其更好，我将不胜感激)以使其工作？

(例如，给定输入 [A5，a5，A5！，a5,!啪��

输出应为 [, !A， ！a， 1， A， A， A5， A5！， a5！])

Answer 1

编辑：添加了您之前提到的测试用例，以指出不一致之处。

---

试一试。我仍然不确定这是否涵盖了您的所有输入要求，但适用于以下测试用例：

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!]

但是对于此测试用例：

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

输出是不同的。 在这种情况下，您的期望似乎不一致，因为此示例对元素 2 和 1 有不同的顺序！

只要是这种情况，试图回答你的问题就没有任何意义。

---

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;
}
}
});

Answer 2

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);

}

根据评论

@Psingh 我们不必处理"!!!"场景。期望值应为 [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);
}