java Arrays.sort 二维数组

Posted 2023-02-14

【中文标题】java Arrays.sort 二维数组

【英文标题】：java Arrays.sort 2d array

【发布时间】：2013-03-05 08:23:16

【问题描述】：

我希望根据 [][0] 的值对以下数组进行排序

double[][] myArr = new double[mySize][2];

例如，myArr 的内容是：

1      5
13     1.55
12     100.6
12.1   .85

我希望它到达：

1      5
12     100.6
12.1   .85
13     1.55

我希望在不必实现自己的排序的情况下做到这一点。

【参考方案1】：

你可以使用自己的排序，很简单。

int[][] matrix = 
            2, 1, 3,
            5, 4, 6,
            8, 7, 9
        ;

for (int k = 0; k < length; k++) 
        for (int i= 0; i < matrix[k].length; i++) 
            for (int j = 0; j < matrix[k].length; j++) 
                if (matrix[k][i] < matrix[k][j]) 
                    int temp = matrix[k][i];
                    matrix[k][i] = matrix[k][j];
                    matrix[k][j] = temp;
                
            
        
    

System.out.println(Arrays.deepToString(matrix));

输出

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

【参考方案2】：

您可以使用的二维整数数组的降序/升序：

Arrays.sort(contests, (a, b) -> Integer.compare(b[0],a[0])); //decreasing order
    
Arrays.sort(contests, (a, b) -> Integer.compare(a[0],b[0]); //increasing order

【参考方案3】：

其实很简单，只是需要记住一些语法。

Arrays.sort(contests, (a, b) -> Integer.compare(a[0],b[0]));//升序---1

Arrays.sort(contests, (b, a) -> Integer.compare(b[0],a[0]));//升序---2

Arrays.sort(contests, (a, b) -> Integer.compare(b[0],a[0]));//降序---3

Arrays.sort(contests, (b, a) -> Integer.compare(a[0],b[0]));//降序---4

如果您仔细观察，那么影响结果的是“a”和“b”顺序的变化。对于第 1 行，集合是 (a,b) 和 Integer.compare(a[0],b[0])，因此它是递增顺序。现在，如果我们改变其中任何一个中 a 和 b 的顺序，假设 (a,b) 和 Integer.compare(b[0],a[0]) 的集合如第 3 行，我们得到降序。

【参考方案4】：

要按降序排序，可以翻转两个参数

int[][] array= 
    1, 5,
    13, 1,
    12, 100,
    12, 85 
;
Arrays.sort(array, (b, a) -> Integer.compare(a[0], b[0]));

输出：

13, 5
12, 100
12, 85
1, 5

【参考方案5】：

更简单的代码：

导入 java.util.Arrays; int[][] 数组 = 新的 int[][];

Arrays.sort(array, (a, b) -> a[1] - b[1]);

【讨论】：

我认为他们想根据索引 0 而不是索引 1 的值进行排序。

【参考方案6】：

Java 8 现在非常普遍。

Arrays.sort(myArr,(double[] a,double[] b)->
                //here multiple lines of code can be placed
                return a[0]-b[0]; 
            );

【参考方案7】：

使用重载Arrays#Sort(T[] a, Comparator c)，它将 Comparator 作为第二个参数。

double[][] array= 
1, 5,
13, 1.55,
12, 100.6,
12.1, .85 ;

java.util.Arrays.sort(array, new java.util.Comparator<double[]>() 
    public int compare(double[] a, double[] b) 
        return Double.compare(a[0], b[0]);
    
);

JAVA-8：我们可以使用如下的 lambda 函数来代替那个大比较器 -

Arrays.sort(array, Comparator.comparingDouble(o -> o[0]));

【讨论】：

那个减法可能行不通；你应该改用Double.compare(b[0], a[0])。

当 sort 需要一维数组时，如何将二维数组作为参数传递？这对我不起作用。

@LouisWasserman 我假设他们在你这么说之前使用了类似a[0] - b[0] 的东西。为什么它不起作用？实际上是a common sorting idiom for numbers。

因为a）它甚至只适用于整数，b）如果你在足够大的整数上尝试它，你会溢出并且它会在你身上爆炸。当您比较的值可能为负时，切勿使用该成语。

如果它们足够大，那不是重点。如果你的数字总是非负数，那没关系，但如果你比较 Integer.MAX_VALUE 和 -1 你会溢出。最好从一开始就做正确的事。

【参考方案8】：

最简单的方法：

Arrays.sort(myArr, (a, b) -> a[0] - b[0]);

【讨论】：

我相信这有时会给出错误的结果，因为下溢/溢出问题。

【参考方案9】：

简化的 Java 8

IntelliJ 建议简化以下问题的最佳答案：

Arrays.sort(queries, Comparator.comparingDouble(a -> a[0]));

【参考方案10】：

欢迎使用 Java 8：

Arrays.sort(myArr, (a, b) -> Double.compare(a[0], b[0]));

【讨论】：

Arrays.sort(myArr, (a, b) -> Double.compare(a[][0], b[][0]));我可以使用它根据二维数组上的列进行排序吗？

是的（还有 12 个以上的字符）

【参考方案11】：

虽然这是一个老线程，但这里有两个解决Java8问题的例子。

按第一列（[][0]）排序：

double[][] myArr = new double[mySize][2];
// ...
java.util.Arrays.sort(myArr, java.util.Comparator.comparingDouble(a -> a[0]));

按前两列排序（[][0]、[][1]）：

double[][] myArr = new double[mySize][2];
// ...
java.util.Arrays.sort(myArr, java.util.Comparator.<double[]>comparingDouble(a -> a[0]).thenComparingDouble(a -> a[1]));

【讨论】：

如何按降序反转？我用java.util.Arrays.sort(myArr, java.util.Comparator.comparingDouble(a -> a[0])).reversed(); 但是IDE给了我一个错误“Array type expected; found: 'java.lang.Object'”

【参考方案12】：

import java.util.*;

public class Arrays2

    public static void main(String[] args)
    
        int small, row = 0, col = 0, z;
        int[][] array = new int[5][5];

        Random rand = new Random();
        for(int i = 0; i < array.length; i++)
        
            for(int j = 0; j < array[i].length; j++)
            
                array[i][j] = rand.nextInt(100);
                System.out.print(array[i][j] + " ");
            
            System.out.println();
        

        System.out.println("\n");


        for(int k = 0; k < array.length; k++)
        
            for(int p = 0; p < array[k].length; p++)
            
                small = array[k][p];
                for(int i = k; i < array.length; i++)
                
                    if(i == k)
                        z = p + 1;
                    else
                        z = 0;
                    for(;z < array[i].length; z++)
                    
                        if(array[i][z] <= small)
                        
                            small = array[i][z];
                            row = i;
                            col = z;
                        
                    
                
            array[row][col] = array[k][p];
            array[k][p] = small;
            System.out.print(array[k][p] + " ");
            
            System.out.println();
        
    

祝你好运

【参考方案13】：

对于一般解决方案，您可以使用Column Comparator。使用该类的代码是：

Arrays.sort(myArr, new ColumnComparator(0));

【讨论】：

有些人不喜欢链接到外部网站的答案。您可能需要考虑更新的方法，因为新功能已添加到该语言中。

这个羽毛是从什么版本开始的？

它不是 Java API 的一部分。它是一个独立的类，可以与任何版本一起使用。

【参考方案14】：

您需要像这样实现Comparator<Double[]>：

public static void main(String[] args) throws IOException 
    final Double[][] doubles = new Double[][]5.0, 4.0, 1.0, 1.0, 4.0, 6.0;
    final Comparator<Double[]> arrayComparator = new Comparator<Double[]>() 
        @Override
        public int compare(Double[] o1, Double[] o2) 
            return o1[0].compareTo(o2[0]);
        
    ;
    Arrays.sort(doubles, arrayComparator);
    for (final Double[] arr : doubles) 
        System.out.println(Arrays.toString(arr));
    

输出：

[1.0, 1.0]
[4.0, 6.0]
[5.0, 4.0]