O método Arrays.sort() em Java é usado para classificar os elementos de um array.

• Ele fornece opções flexíveis para classificar subarrays de arrays inteiros ou até mesmo objetos personalizados usando comparadores.
• Pode classificar matrizes primitivas (int char etc.) e matrizes de objetos (string inteira etc.).

Exemplo: Classificando matrizes de inteiros e caracteres em ordem crescente

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] 

Explicação:

• Arrays.sort() reordena os elementos em ordem crescente.
• As duplicatas não são removidas.
• Matrizes primitivas não podem usar comparadores personalizados.

Sintaxe do método Arrays.sort()

1. Para classificar todo o array

Matrizes.sort(); 

2. Para classificar um subarray

public static void sort(int[] arr int from_Index int to_Index);

Parâmetros:

• chegar : A matriz a ser classificada.
• de_Índice: O índice do primeiro elemento (inclusive) a ser classificado.
• para_índice : O índice do último elemento (exclusivo) a ser classificado.
• Tipo de retorno: void (este método não retorna nada).

Observação:

• Arrays.sort() não remove duplicatas; ele apenas reordena os elementos.
• Os tipos primitivos não podem usar comparadores personalizados; a classificação está em ordem natural (crescente).

Exemplo: Classificando Subarray

Você pode classificar uma parte de uma matriz especificando os índices inicial (inclusivo) e final (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] 

Explicação: Somente os elementos nos índices 1, 2 e 3 são classificados; o elemento no índice 0 permanece inalterado.

Classificação por ordem decrescente

Para classificar um array em ordem decrescente, podemos usar o método Arrays.sort() com 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] 

Explicação:

• Funciona apenas em matrizes de objetos; tipos primitivos (int) não podem usar comparadores.
• Para Strings classifica lexicograficamente de Z -> A.

Classificação personalizada com comparador

Podemos classificar uma matriz de objetos definindo uma lógica de classificação personalizada com a ajuda do uso do  Interface do 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 

Explicação:

• O Comparator permite lógica de classificação personalizada sem modificar a classe.
• Aqui os alunos são classificados por número de rolo.

Classificação natural com interface comparável

No exemplo abaixo, classificamos uma matriz de objetos Student com base em seus nomes em ordem alfabética.

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 

Explicação:

• Neste exemplo usamos o Interface comparável para definir uma ordem natural para os objetos Student.
• Ao implementar o método, especificamos como dois objetos Aluno devem ser comparados, permitindo a classificação com base no nome do aluno.

Isso nos permite usar o método Arrays.sort() diretamente em uma matriz de objetos Student para classificá-los em uma ordem e aqui não precisamos de um comparador separado.