java les Tableaux.tri de tableau 2d

DONC,

Je suis looknig pour trier le tableau suivant, basé sur les valeurs de [][0]

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

donc, pour ex, myArr contenu est:

1      5
13     1.55
12     100.6
12.1   .85

Je veux obtenir :

1      5
12     100.6
12.1   .85
13     1.55

Je suis à la recherche de le faire sans avoir à implémenter mon propre tri. Toute aide est appréciée, merci.

Utiliser un Comparator.

OriginalL'auteur Dax Durax | 2013-03-16

  1. 40

    Utilisation Surchargé Tableaux#Tri(T [], Comparateur c) qui prend Comparateur comme deuxième argument.

    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]);
    }
});
    Que la soustraction ne sera probablement pas travailler; vous devez utiliser Double.compare(b[0], a[0]) à la place.
    ahh, c'est vrai, édité, merci:)
    Comment pouvez-vous vous passer de la 2D tableau en argument lors de trier attend un tableau 1D? Cela n'a pas fonctionné pour moi.
    Je suis en supposant qu'ils ont été en utilisant quelque chose comme a[0] - b[0] avant de vous le dire. Pourquoi ne serait-il pas de travail? C'est en fait un tri commun idiome pour les nombres.
    Pas si ils sont assez grands, est le point. Si vos numéros sont toujours positifs, c'est bien, mais si vous comparez Integer.MAX_VALUE à -1 vous obtiendrez de débordement. C'est juste mieux de faire la bonne chose dès le début.

    OriginalL'auteur PermGenError

  2. 17

    Bienvenue Java 8:

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

    OriginalL'auteur Gevorg

  3. 6

    Vous avez besoin pour mettre en œuvre un Comparator<Double[]> comme suit:

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

    De sortie:

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

    OriginalL'auteur Boris the Spider

  4. 2

    Bien que c'est un vieux thread, voici deux exemples pour résoudre le problème de Java8.

    tri par la première colonne ([][0]): 

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

    de tri par les deux premières colonnes ([][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]));

    OriginalL'auteur John

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

    Bonne Chance

    OriginalL'auteur Nasser Al kaabi

  6. 0

    Simplifié De Java 8

    IntelliJ suggère de simplifier le haut de répondre à la:

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

    OriginalL'auteur kyxap

  7. -1

    Pour une solution générale, vous pouvez utiliser le Colonne De Comparaison. Le code à utiliser la classe serait:

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

    OriginalL'auteur camickr