Trier un tableau 2D en Java

1. Utilisez java.util.Arrays.sort(T[] a, Comparator<? super T> c) pour trier un tableau 2D en fonction des colonnes
2. Utilisez java.util.Arrays.sort(T[] a) pour trier les tableaux 2D par ligne

Dans ce tutoriel, nous apprendrons à trier un tableau 2D en Java. Un tableau 2D est un tableau dont les éléments sont des tableaux 1-D. Les éléments d’un tableau 2D sont disposés en lignes et en colonnes sous la forme d’une matrice.

Utilisez java.util.Arrays.sort(T[] a, Comparator<? super T> c) pour trier un tableau 2D en fonction des colonnes

java.util.Arrays.sort(T[] a, Comparator<? super T> c) est l’une des rares méthodes utilitaires fournies par la classe Arrays. Cette méthode trie le tableau spécifié selon l’ordre activé par le comparateur spécifié. Les éléments du tableau doivent être mutuellement comparables et ne doivent donc pas lancer d’exception ClassCastException.

Ici, multi est un tableau bidimensionnel sous forme de matrice qui a trois lignes et trois colonnes. Nous allons trier ce tableau en prenant sa troisième colonne comme référence.

Nous passons une implémentation de l’interface java.util.Comparator à la méthode Arrays.sort(). L’interface Comparator définit une méthode compare qui compare ses deux arguments pour l’ordre. Elle retourne zéro si les objets passés sont égaux. Elle retourne une valeur positive si first[columnNumber-1] est supérieur à second[columnNumber-1]. Sinon, elle renvoie une valeur négative.

La troisième colonne de multi a 8, 2, et 6 comme éléments. Elle compare ces valeurs et modifie l’ordre du tableau 2D en ordre croissant.

import java.util.Arrays;
import java.util.Comparator;

public class Sort2DArray {
  public static void main(String args[]) {
    int[][] multi = new int[][] {
        {4, 9, 8},
        {7, 5, 2},
        {3, 0, 6},

    };
    for (int i = 0; i < multi.length; i++) {
      for (int j = 0; j < multi[i].length; j++) System.out.print(multi[i][j] + " ");
      System.out.println();
    }
    // sort according to 3 column
    Sort2DArrayBasedOnColumnNumber(multi, 3);
    System.out.println("after sorting");
    for (int i = 0; i < multi.length; i++) {
      for (int j = 0; j < multi[i].length; j++) System.out.print(multi[i][j] + " ");
      System.out.println();
    }
  }
  public static void Sort2DArrayBasedOnColumnNumber(int[][] array, final int columnNumber) {
    Arrays.sort(array, new Comparator<int[]>() {
      @Override
      public int compare(int[] first, int[] second) {
        if (first[columnNumber - 1] > second[columnNumber - 1])
          return 1;
        else
          return -1;
      }
    });
  }
}

Production :

4 9 8 
7 5 2 
3 0 6 
after sorting
7 5 2 
3 0 6 
4 9 8 

Utilisez java.util.Arrays.sort(T[] a) pour trier les tableaux 2D par ligne

Ici, dans le code, array[][] est un tableau en 2D. Il comporte 4 lignes et 4 colonnes. Nous allons trier la ligne individuelle de ce tableau en utilisant la méthode Arrays.sort() qui prend un tableau comme argument. Cette méthode trie le tableau spécifié par ordre numérique croissant.

La méthode sortRowWise exécute une boucle for jusqu’à la longueur de notre tableau. Elle prend une ligne individuelle de array[][] et la trie dans l’ordre croissant, indiqué dans la sortie.

import java.util.Arrays;
public class Sort2DArray {
  public static void main(String args[]) {
    int array[][] = {{7, 8, 2, 1}, {0, 3, 2, 9}, {6, 5, 3, 2}, {8, 3, 7, 9}};

    sortRowWise(array);
  }

  static int sortRowWise(int arr[][]) {
    // One by one sort individual rows.
    for (int i = 0; i < arr.length; i++) {
      Arrays.sort(arr[i]);
    }

    for (int i = 0; i < arr.length; i++) {
      for (int j = 0; j < arr[i].length; j++) System.out.print(arr[i][j] + " ");
      System.out.println();
    }

    return 0;
  }
}

Production :

1 2 7 8
0 2 3 9
2 3 5 6
3 7 8 9