Java - 自定义排序数组，就好像它们是元组一样

Question

假设我有三个这样的数组:

a = [1, 2, 1, 4, 1]
b = [6, 1, 2, 4, 3]
c = [9, 6, 4, 7, 8]

我想对它们进行排序，就像它们是一个元组(a，b，c)一样，所以结果应该如下所示:

a    |    b    |    c
----------------------
1         2         4
1         3         8
1         6         9
2         1         6
4         4         7

我想编写 Java 代码，以尽可能最有效的方式执行此操作。谢谢!

Answer 1

您应该创建一个实现 Comparable 接口(interface)的包装对象，将数组中的值映射到该包装类的实例，排序并使用这些值。

示例:

    static class X implements Comparable<X> {
        final int a;
        final int b;
        final int c;
        public X(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
        
        public int getA() {return a;}
        public int getB() {return b;}
        public int getC() {return c;}
        
        @Override
        public int compareTo(X that) {
            int cmp = Integer.compare(this.a, that.a);
            if (cmp == 0) {
                cmp = Integer.compare(this.b, that.b);
                if (cmp == 0) {
                    cmp = Integer.compare(this.c, that.c);
                }
            }
            return cmp;
        }
    }

    public static void main(String[] args){
        int[] a = {1, 2, 1, 4, 1};
        int[] b = {6, 1, 2, 4, 3};
        int[] c = {9, 6, 4, 7, 8};
        
        IntStream.range(0, a.length)
                 .mapToObj(i -> new X(a[i], b[i], c[i]))
                 .sorted()
                 .forEach(x -> {
                     System.out.printf("%d\t%d\t%d\t\n", x.getA(), x.getB(), x.getC()); 
                 });
    }

此代码打印预期输出:

1   2   4   
1   3   8   
1   6   9   
2   1   6   
4   4   7

如果需要，您可以将排序后的值设置回初始数组。

更新 您还可以使用 solution offered by Gerold Boser 的改进版本尽管它对输入整数的范围和/或数组的数量有一定的限制:

static int m = 0;

public static void main(String[] args) {
    // range of integer values for 3 arrays is -2^20 ... 2^20 -1
    // or 0..2^21 -1
    final int[] a = { Integer.MAX_VALUE>>11, 1, 1, -4, Integer.MIN_VALUE/(1<<11) };
    final int[] b = { 6, 1, 1, 4, 3 };
    final int[] c = { 9, -6, -24, 7, 8 };

    IntSummaryStatistics stats = 
        Stream.of(Arrays.stream(a), Arrays.stream(b), Arrays.stream(c))
              .flatMapToInt(s -> s)
              .summaryStatistics();
    long min = stats.getMin();
    long max = stats.getMax() - min + 1;

    IntStream.range( 0, a.length )
             // use long to fit multiplication results into 63 bits
             .mapToLong( i -> (a[i] - min) * max * max + (b[i]-min) * max + (c[i]-min) )
             .sorted()
             .forEach( n -> {
                 // re-calculate long back to ints
                 a[m] = (int) (n / (max * max) % max + min);
                 b[m] = (int) (n / max % max + min);
                 c[m] = (int) (n % max + min);
                 System.out.printf("% 9d\t% d\t% d\t\n", a[m], b[m], c[m]);
                 m++;
             });
}

输出:

 -1048576    3   8  
       -4    4   7  
        1    1  -24 
        1    1  -6  
  1048575    6   9

注意可以通过使用 BigDecimal 而不是 long 来克服上述限制，以避免执行乘法时溢出