在 Integer.MIN_VALUE、Integer.MAX_VALUE 值之间使用 Arrays.sort 和 Comparator答案

【问题标题】：using Arrays.sort between Integer.MIN_VALUE, Integer.MAX_VALUE values with Comparator在 Integer.MIN_VALUE、Integer.MAX_VALUE 值之间使用 Arrays.sort 和 Comparator
【发布时间】：2019-05-04 21:36:57
【问题描述】：

我有这个带有 int 字段的 Java 类，以及这个问题不需要的其他字段。

class MyInteger {

  int integer;

  public MyInteger(int integer) {
    this.integer = integer;
  }

  public int getInteger() {
    return integer;
  }

  public void setInteger(int integer) {
    this.integer = integer;
  }

}

现在我测试我的课程

首先：我用整数创建了数组。

int size = 12;
MyInteger[] integers = new MyInteger[size];
for (int p = 0; p < size; p++) {
  integers[p] = new MyInteger(
      java.util.concurrent.ThreadLocalRandom.current().nextInt(
      Integer.MIN_VALUE, Integer.MAX_VALUE)
    );
}

现在打印出来。

System.out.println("UNSORTED");
for (int p = 0; p < size; p++) {
  int length = String.valueOf(integers[p].getInteger()).length();
  String stringValue = new String(new char[12 - length]).replace("\0", " ") + integers[p].getInteger();
  System.out.println("p:" + p + " -> " + stringValue);
}

在这里，我正在尝试对其进行排序。

Arrays.sort(integers, new Comparator<MyInteger>() {
  @Override
  public int compare(MyInteger myInteger1, MyInteger myInteger2) {
    return myInteger2.getInteger() - myInteger1.getInteger();
  }
});

再打印一次

System.out.println("DESCENDING");
for (int p = 0; p < size; p++) {
  int length = String.valueOf(integers[p].getInteger()).length();
  String stringValue = new String(new char[12 - length]).replace("\0", " ") + integers[p].getInteger();
  System.out.println("p:" + p + " -> " + stringValue);
}

现在我的输出...

    UNSORTED
    p:0 ->   1516262435
    p:1 ->  -1895913122
    p:2 ->    460516193
    p:3 ->   2056891047
    p:4 ->   1556892429
    p:5 ->    609045519
    p:6 ->  -1105298052
    p:7 ->   1015464430
    p:8 ->   -232510140
    p:9 ->     28575513
    DESCENDING
    p:0 ->  -1105298052
    p:1 ->  -1895913122
    p:2 ->   2056891047
    p:3 ->   1556892429
    p:4 ->   1516262435
    p:5 ->   1015464430
    p:6 ->    609045519
    p:7 ->    460516193
    p:8 ->     28575513
    p:9 ->   -232510140

我知道，因为有时 (int2 - int1) 的容量（以位为单位）大于简单 int 什么是我更好的选择？

【问题讨论】：

标签： java arrays integer comparator

【解决方案1】：

您可以在 Comparator 中使用 Integer.compare() 来实现此目的：

Arrays.sort(integers, (i1, i2) -> Integer.compare(i2.getInteger(), i1.getInteger()));

使用Comparator.comparingInt() 甚至更短：

Arrays.sort(integers, Comparator.comparingInt(MyInteger::getInteger).reversed());

这两种情况的结果应该是这样的：

DESCENDING
p:0 ->   2023840480
p:1 ->   1411652946
p:2 ->   1329894719
p:3 ->   1158939955
p:4 ->    652971815
p:5 ->   -118538025
p:6 ->   -157722835
p:7 ->  -1370854542
p:8 ->  -1925460195
p:9 ->  -1937778542

【讨论】：

我不认为Integer.compare的实际实现是相关的。重要的是，使用减号代替比较是错误的，而Integer.compare 会做对。 JVM 的优化器有可能将 Integer.compare 的调用替换为内部操作，但无论它如何工作，都可以保证不会出现使用减号的溢出问题。
@Holger 是的，没错。这只是为了向 OP 展示使用 Integer.compare(); 不会出现任何溢出问题，因为 OP 在使用该解决方案时遇到了一些问题。我现在可以删除那部分了。