Java 按长度对字符串排序

这是我对jdk 8环境的测试。当s1.length（）大于s2.length（）时，比较器返回一个负数，因此s1位于s2的前面。但结果是[“B”，“AA”]。怎么了

---

当s1.length（）大于s2.length（）时，比较器返回一个正数，因此s2位于s1前面。结果是[“B”，“AA”]。我只是犯了一个愚蠢的错误。

逻辑是倒退的。听起来好像要从s2.length（）中减去s1.length（）。

逻辑是反向的。听起来好像要从s2.length（）中减去s1.length（）。

逻辑是反向的。听起来好像要从s2.length（）中减去s1.length（）。

逻辑是反向的。听起来好像要从s2.length（）中减去s1.length（）。

让我们修改它以记录值

 String[] arrays = {"AA", "B"};
 Arrays.sort(arrays, (s1, s2)->s1.length()-s2.length());
 System.out.println(Arrays.toString(arrays));

这张照片

String[] arrays = { "AA", "B" };
Arrays.sort(arrays, (s1, s2) -> {
    System.out.println("s1: " + s1);
    System.out.println("s2: " + s2);
    return s1.length() - s2.length();
});
System.out.println(Arrays.toString(arrays));

B

的长度小于

AA

，因此

s1: B
s2: AA
[B, AA]

---

返回一个负值。

sort

方法接受该值并在数组中翻转它们。

让我们修改它以记录值

 String[] arrays = {"AA", "B"};
 Arrays.sort(arrays, (s1, s2)->s1.length()-s2.length());
 System.out.println(Arrays.toString(arrays));

return s1.length() - s2.length();

这张照片

String[] arrays = { "AA", "B" };
Arrays.sort(arrays, (s1, s2) -> {
    System.out.println("s1: " + s1);
    System.out.println("s2: " + s2);
    return s1.length() - s2.length();
});
System.out.println(Arrays.toString(arrays));

B

的长度小于

AA

，因此

s1: B
s2: AA
[B, AA]

---

返回一个负值。

sort

方法接受该值并在数组中翻转它们。

让我们修改它以记录值

 String[] arrays = {"AA", "B"};
 Arrays.sort(arrays, (s1, s2)->s1.length()-s2.length());
 System.out.println(Arrays.toString(arrays));

return s1.length() - s2.length();

这张照片

String[] arrays = { "AA", "B" };
Arrays.sort(arrays, (s1, s2) -> {
    System.out.println("s1: " + s1);
    System.out.println("s2: " + s2);
    return s1.length() - s2.length();
});
System.out.println(Arrays.toString(arrays));

B

的长度小于

AA

，因此

s1: B
s2: AA
[B, AA]

---

返回一个负值。

sort

方法接受该值并在数组中翻转它们。

让我们修改它以记录值

 String[] arrays = {"AA", "B"};
 Arrays.sort(arrays, (s1, s2)->s1.length()-s2.length());
 System.out.println(Arrays.toString(arrays));

return s1.length() - s2.length();

这张照片

String[] arrays = { "AA", "B" };
Arrays.sort(arrays, (s1, s2) -> {
    System.out.println("s1: " + s1);
    System.out.println("s2: " + s2);
    return s1.length() - s2.length();
});
System.out.println(Arrays.toString(arrays));

B

的长度小于

AA

，因此

s1: B
s2: AA
[B, AA]

返回一个负值。

sort

方法接受该值并在数组中翻转它们

return s1.length() - s2.length();

比较方法以这种方式工作和返回

o1 - object1 in your case s1
o2 - object2 in your case s2

o/p

在下面的情况下，如果我们反转返回参数，如下所示

B
AA
[B, AA]

它返回正数，因此按先大后小的降序排序

而o/p是

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s1.length();
    }

现在只返回0

B
AA
[AA, B]

o/p-未进行排序，因为它假定所有即将到来的对象都相等

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s2.length();
    }

如果有任何问题，请告诉我

比较方法以这种方式工作和返回

o1 - object1 in your case s1
o2 - object2 in your case s2

o/p

在下面的情况下，如果我们反转返回参数，如下所示

B
AA
[B, AA]

它返回正数，因此按先大后小的降序排序

而o/p是

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s1.length();
    }

现在只返回0

B
AA
[AA, B]

o/p-未进行排序，因为它假定所有即将到来的对象都相等

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s2.length();
    }

如果有任何问题，请告诉我

比较方法以这种方式工作和返回

o1 - object1 in your case s1
o2 - object2 in your case s2

o/p

在下面的情况下，如果我们反转返回参数，如下所示

B
AA
[B, AA]

它返回正数，因此按先大后小的降序排序

而o/p是

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s1.length();
    }

现在只返回0

B
AA
[AA, B]

o/p-未进行排序，因为它假定所有即将到来的对象都相等

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s2.length();
    }

如果有任何问题，请告诉我

比较方法以这种方式工作和返回

o1 - object1 in your case s1
o2 - object2 in your case s2

o/p

在下面的情况下，如果我们反转返回参数，如下所示

B
AA
[B, AA]

它返回正数，因此按先大后小的降序排序

而o/p是

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s1.length();
    }

现在只返回0

B
AA
[AA, B]

o/p-未进行排序，因为它假定所有即将到来的对象都相等

public int compare(String s1, String s2) {
        System.out.println(s1);
        System.out.println(s2);
        return s2.length() - s2.length();
    }

---

任何问题请告诉我。

当返回负数时，s1在s2前面，s1.length大于s2，所以我认为当返回负数时，s1在s2前面，s1.length大于s2，所以当返回负数时，s1在s2前面，所以我认为reuslt应该是[“AA”，“B”]，s1.length比s2大，所以我认为当返回负数时，reuslt应该是[“AA”，“B”]，s1在s2前面，s1.length比s2大，所以我认为reuslt应该是[“AA”，“B”]是否要将字符串数组从最短到最大排序（仅检查长度）？你能解释一下你到底想要什么吗？你想把字符串数组从最短到最大排序（只检查长度）？你能解释一下你到底想要什么吗？你想把字符串数组从最短到最大排序（只检查长度）？你能解释一下你到底想要什么吗？你想把字符串数组从最短到最大排序（只检查长度）？你能解释一下你到底想要什么吗？