Ordenar Array 2D en Java

1. Utiliza java.util.Arrays.sort(T[] a, Comparator<? super T> c) para ordenar un array 2D dada la columna Sabe
2. Usa java.util.Arrays.sort(T[] a) para ordenar un array 2D por filas

En este tutorial, aprenderemos a ordenar un array 2D en Java. Un array 2D es un array cuyos elementos son arrays 1-D. Los elementos de un array 2D están ordenados en filas y columnas en forma de array.

Utiliza java.util.Arrays.sort(T[] a, Comparator<? super T> c) para ordenar un array 2D dada la columna Sabe

El método java.util.Arrays.sort(T[] a, Comparator<? super T> c) es uno de los pocos métodos de utilidad proporcionados por la clase Arrays. Este método ordena el array especificado según el orden actuado por el comparador especificado. Los elementos del array deben ser mutuamente comparables, por lo que no debe lanzar una ClassCastException.

Aquí multi es un array bidimensional en forma de array que tiene tres filas y tres columnas. Vamos a ordenar esta matriz tomando como referencia su tercera columna.

Pasamos una implementación de la interfaz java.util.Comparator al método Arrays.sort(). La interfaz Comparator define un método compare que compara el orden de sus dos argumentos. Devuelve cero si los objetos pasados son iguales. Devuelve un valor positivo si first[columnNumber-1] es mayor que second[columnNumber-1]. En caso contrario, devuelve un valor negativo.

La tercera columna de multi tiene como elementos 8, 2 y 6. Compara estos valores y altera el orden del array 2D en orden ascendente.

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

Producción :

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) para ordenar un array 2D por filas

Aquí en el código, array[][] es un array 2D. Tiene 4 filas y 4 columnas. Vamos a ordenar cada fila de este array utilizando el método Arrays.sort() que toma un array como argumento. Este método ordena el array especificado en orden numérico ascendente.

El método sortRowWise ejecuta un bucle for hasta la longitud de nuestro array. Toma una fila individual del array[][] y la ordena en orden ascendente, como se muestra en la salida.

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

Producción :

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