Arrays.sort() em Java
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
Java 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 )); } }
Saída
[-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).
Java 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 )); } }
Saída
[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.
Java 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 )); } }
Saída
[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 .
Java 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 ); } }
Saída
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.
Java 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 ); } }
Saída
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.
Criar questionário
