El método Arrays.sort() en Java se utiliza para ordenar los elementos de una matriz.

• Proporciona opciones flexibles para ordenar subarreglos de matrices completas o incluso objetos personalizados mediante comparadores.
• Puede ordenar tanto matrices primitivas (int char, etc.) como matrices de objetos (cadenas enteras, etc.).

Ejemplo: Ordenar matrices de números enteros y caracteres en orden ascendente

import java.util.Arrays; class Geeks{    public static void main(String[] args) {  // Integer array  int[] arr1 = {2 -1 3 4};  // Character array  char[] arr2 = {'b' 'a' 'c' 'b'};  // Sorting arrays in ascending order  Arrays.sort(arr1);   Arrays.sort(arr2);  // Print sorted arrays  System.out.println(Arrays.toString(arr1));   System.out.println(Arrays.toString(arr2));  } } 

[-1 2 3 4] [a b b c] 

Explicación:

• Arrays.sort() reordena los elementos en orden ascendente.
• Los duplicados no se eliminan.
• Las matrices primitivas no pueden utilizar comparadores personalizados.

Sintaxis del método Arrays.sort()

1. Para ordenar toda la matriz

matrices.sort(); 

2. Para ordenar un subarreglo

clasificación de vacío estático público (int[] arr int from_Index int to_Index);

Parámetros:

• llegar : La matriz que se va a ordenar.
• desde_Índice: El índice del primer elemento (inclusive) que se va a ordenar.
• to_Index : El índice del último elemento (exclusivo) que se ordenará.
• Tipo de devolución: void (Este método no devuelve nada).

Nota:

• Arrays.sort() no elimina duplicados; solo reordena elementos.
• Los tipos primitivos no pueden utilizar comparadores personalizados; la clasificación se realiza en orden natural (ascendente).

Ejemplo: ordenar submatriz

Puede ordenar una parte de una matriz especificando índices de inicio (inclusive) y fin (exclusivo).

import java.util.Arrays; public class Geeks{    public static void main(String[] args){  int[] arr = {2 -1 4 3};  // Sort elements from index 1 to 3  Arrays.sort(arr 1 4);  // Print array after sorting subarray  System.out.println(Arrays.toString(arr));  } } 

[2 -1 3 4] 

Explicación: Sólo se ordenan los elementos de los índices 1, 2 y 3; el elemento en el índice 0 permanece sin cambios.

Clasificación en orden descendente

Para ordenar una matriz en orden descendente podemos usar el método Arrays.sort() con Collections.reverseOrder() como comparador.

import java.util.Arrays; import java.util.Collections; public class Geeks{  public static void main(String[] args) {  // Integer array  Integer[] arr = {2 -1 3 4};  Arrays.sort(arr Collections.reverseOrder());   System.out.println(Arrays.toString(arr));   // String array  String[] str = {'Hii' 'Vishnu' 'chauhan'};  Arrays.sort(str Collections.reverseOrder());   System.out.println(Arrays.toString(str));  } } 

[4 3 2 -1] [chauhan Vishnu Hii] 

Explicación:

• Funciona sólo en matrices de objetos; Los tipos primitivos (int) no pueden usar comparadores.
• For Strings ordena lexicográficamente desde Z -> A.

Clasificación personalizada con comparador

Podemos ordenar una serie de objetos definiendo una lógica de clasificación personalizada con la ayuda del uso de  Interfaz del comparador .

import java.util.*; // Custom class class Student{    int roll;  String name;  String address;  Student(int roll String name String address){    this.roll = roll;  this.name = name;  this.address = address;  }  // Print student details  public String toString() {  return roll + ' ' + name + ' ' + address;  } } // Comparator to sort by roll number class SortByRoll implements Comparator<Student>{    public int compare(Student s1 Student s2){    return s1.roll - s2.roll;  } } class Geeks {  public static void main(String[] args){  Student[] students = {  new Student(1 'Ram' 'MP')  new Student(2 'Shyam' 'UP')  new Student(3 'Hari' 'Delhi')  };  // Sort using custom comparator  Arrays.sort(students new SortByRoll());  // Print sorted students  for (Student s : students)  System.out.println(s);  } } 

1 Ram MP 2 Shyam UP 3 Hari Delhi 

Explicación:

• Comparator permite una lógica de clasificación personalizada sin modificar la clase.
• Aquí los estudiantes se clasifican por número de lista.

Clasificación natural con interfaz comparable

En el siguiente ejemplo, ordenamos alfabéticamente una matriz de objetos Estudiante según su nombre.

import java.util.Arrays; class Student implements Comparable<Student>{    int r;  String n;  String a;  // Constructor  public Student(int r String n String a){    this.r = r;  this.n = n;  this.a = a;  }  // compareTo method to sort by name  public int compareTo(Student o){    return this.n.compareTo(o.n);  }  // toString() method to print Student details  public String toString() {  return this.r + ' ' + this.n + ' ' + this.a;  } } public class Geeks{    public static void main(String[] args){    Student[] s = {  new Student(1 'Ram' 'UP')  new Student(2 'Shyam' 'MP')  new Student(3 'Hari' 'Bihar')  };  // Sorting students by name in alphabetical order  Arrays.sort(s);  for (Student student : s)  System.out.println(student);  } } 

3 Hari Bihar 1 Ram UP 2 Shyam MP 

Explicación:

• En este ejemplo utilizamos el Interfaz comparable para definir un orden natural para los objetos de Estudiante.
• Al implementar el método, especificamos cómo se deben comparar dos objetos Estudiante al permitir la clasificación según el nombre del estudiante.

Esto nos permite usar el método Arrays.sort() directamente en una matriz de objetos Student para ordenarlos y aquí no necesitamos un comparador separado.