Ordina array 2D in Java

1. Usa java.util.Arrays.sort(T[] a, Comparator<? super T> c) per ordinare un array 2D in base alla colonna
2. Usa java.util.Arrays.sort(T[] a) per ordinare la matrice 2D per riga

In questo tutorial impareremo come ordinare un array 2D in Java. Un array 2D è un array i cui elementi sono array 1-D. Gli elementi in un array 2D sono disposti in righe e colonne sotto forma di un array.

Usa java.util.Arrays.sort(T[] a, Comparator<? super T> c) per ordinare un array 2D in base alla colonna

java.util.Arrays.sort(T[] a, Comparator<? super T> c) è uno dei pochi metodi di utilità forniti dalla classe Arrays. Questo metodo ordina l’array specificato in base all’ordine attivato dal comparatore specificato. Gli elementi nell’array devono essere reciprocamente confrontabili, quindi non dovrebbero generare un’eccezione ClassCastException.

Qui multi è un array bidimensionale in forma di matrice che ha tre righe e tre colonne. Ordineremo questo array prendendo come riferimento la sua terza colonna.

Passiamo un’implementazione dell’interfaccia java.util.Comparator al metodo Arrays.sort(). L’interfaccia Comparator definisce un metodo compare che confronta i suoi due argomenti per l’ordine. Restituisce zero se gli oggetti passati sono uguali. Restituisce un valore positivo se first[columnNumber-1] è maggiore di second[columnNumber-1]. In caso contrario, restituisce un valore negativo.

La terza colonna di multi ha 8, 2 e 6 come elementi. Confronta questi valori e altera l’ordine di un array 2D in ordine crescente.

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

Produzione:

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

Usa java.util.Arrays.sort(T[] a) per ordinare la matrice 2D per riga

Qui nel codice, array[][] è un array 2D. Ha 4 righe e 4 colonne. Ordineremo la singola riga di questo array usando il metodo Arrays.sort() che accetta un array come argomento. Questo metodo ordina l’array specificato in ordine numerico crescente.

Il metodo sortRowWise esegue un cicli for fino alla lunghezza del nostro array. Prende una singola riga di array[][] e la ordina in ordine crescente, mostrato nell’output.

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

Produzione:

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