Java Arrays.Sort 2D array

Ik ben op zoek naar de volgende array op basis van de waarden van [] [0]

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

Dus bijvoorbeeld, myarr-inhoud is:

1      5
13     1.55
12     100.6
12.1   .85

Ik wil het om naar:

1      5
12     100.6
12.1   .85
13     1.55

Ik ben op zoek om dit te doen zonder mijn eigen soort te hoeven implementeren.

Antwoord 1, Autoriteit 100%

Gebruik overbelaste arrays # sorteren (t [] A, comparator C) die comparator als het tweede argument neemt.

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: In plaats van die grote comparator, kunnen we Lambda-functie gebruiken als volgt –

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

Antwoord 2, Autoriteit 66%

WELKOM JAVA 8:

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

Antwoord 3, Autoriteit 24%

De eenvoudigste manier:

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

Antwoord 4, autoriteit 7%

Je moet een Comparator<Double[]>implementeren zoals:

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

Uitvoer:

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

Antwoord 5, autoriteit 6%

Hoewel dit een oude thread is, zijn hier twee voorbeelden om het probleem in Java8 op te lossen.

sorteren op de eerste kolom ([][0]):

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

sorteren op de eerste twee kolommen ([][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]));

Antwoord 6, autoriteit 5%

Aflopende/toenemende volgorde voor een geheeltallige array van 2 dimensies die u kunt gebruiken:

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

Antwoord 7, autoriteit 3%

Vereenvoudigde Java 8

IntelliJ stelt voor om het eerste antwoord te vereenvoudigen tot de:

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

Antwoord 8, autoriteit 3%

Om in aflopende volgorde te sorteren, kunt u de twee parameters omdraaien

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

Uitvoer:

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

Antwoord 9

veel eenvoudigere code:

java.util.Arrays importeren;
int[][] array = nieuw int[][];

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

Antwoord 10

Het is heel eenvoudig, er zijn slechts enkele syntaxis waarmee u rekening moet houden.

Arrays.sort(wedstrijden, (a, b) -> Integer.compare(a[0],b[0]));//volgorde verhogen —1

Arrays.sort(wedstrijden, (b, a) -> Integer.compare(b[0],a[0]));//volgorde verhogen —2

Arrays.sort(wedstrijden, (a, b) -> Integer.compare(b[0],a[0]));//afnemende volgorde —3

Arrays.sort(wedstrijden, (b, a) -> Integer.compare(a[0],b[0]));//afnemende volgorde —4

Als u zorgvuldig opmerkt, is het de wijziging in de volgorde van ‘A’ en ‘B’ die het resultaat beïnvloedt. Voor regel 1 is de set van (a, b) en integer.compare (A [0], B [0]), dus het is een toenemende volgorde. Nu, als we de volgorde van A en B in een van hen wijzigen, stel dan de set van (a, b) en integer.compare (B [0], A [0]) zoals in lijn 3, we krijgen afnemende volgorde.

Antwoord 11

Voor een algemene oplossing kunt u de kolomcomparator gebruiken. De code om de klasse te gebruiken zou zijn:

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

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

Veel succes

Antwoord 13

Java 8 is tegenwoordig heel gewoon.

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