Question

SO，

我很期待根据[] [0]

的值对以下数组进行排序

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

所以对于ex，myArr的内容是：

1      5
13     1.55
12     100.6
12.1   .85

我希望它能够：

1      5
12     100.6
12.1   .85
13     1.55

我希望这样做而不必实现我自己的排序。感谢任何帮助。谢谢。

Answer 1

使用重载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]);
    }
});

Answer 2

欢迎使用Java 8：

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

Answer 3

您需要实现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]

Answer 4

虽然这是一个旧线程，但这里有两个解决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]));

Answer 5

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

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

输出：

Answer 6

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

祝你好运

Answer 7

简体Java 8

IntelliJ建议简化以下方面的最佳答案：

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

Answer 8

最简单的方法：

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

Answer 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]);//decreasing order

Answer 10

Java 8在当今非常普遍。

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

Answer 11

更简单的代码：

import java.util.Arrays; int [] [] array = new int [] [];

Arrays.sort（array，（a，b）-> a [1]-b [1]）;

Answer 12

这真的很简单，你只需要记住一些语法。

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 行，我们得到降序。

Answer 13

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

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

java Arrays.sort 2d数组

13 个答案: