Arrays.sort() en Java
La méthode Arrays.sort() en Java est utilisée pour trier les éléments d'un tableau.
- Il fournit des options flexibles pour trier des sous-tableaux de tableaux entiers ou même des objets personnalisés à l'aide de comparateurs.
- Peut trier à la fois les tableaux primitifs (int char, etc.) et les tableaux d'objets (Integer String, etc.).
Exemple: Tri des tableaux d'entiers et de caractères par ordre croissant
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 )); } }
Sortir
[-1 2 3 4] [a b b c]
Explication:
- Arrays.sort() réorganise les éléments par ordre croissant.
- Les doublons ne sont pas supprimés.
- Les tableaux primitifs ne peuvent pas utiliser de comparateurs personnalisés.
Syntaxe de la méthode Arrays.sort()
1. Pour trier l'ensemble du tableau
Tableaux.sort();
2. Pour trier un sous-tableau
public static void sort(int[] arr int from_Index int to_Index) ;
Paramètres :
- arr : Le tableau à trier.
- from_Index : L'index du premier élément (inclus) à trier.
- vers_Index : L'index du dernier élément (exclusif) à trier.
- Type de retour : void (Cette méthode ne renvoie rien).
Note:
- Arrays.sort() ne supprime pas les doublons ; il réorganise uniquement les éléments.
- Les types primitifs ne peuvent pas utiliser de comparateurs personnalisés ; le tri se fait par ordre naturel (croissant).
Exemple : tri de sous-tableau
Vous pouvez trier une partie d'un tableau en spécifiant des indices de début (inclus) et de fin (exclusifs).
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 )); } }
Sortir
[2 -1 3 4]
Explication: Seuls les éléments aux indices 1, 2 et 3 sont triés ; l'élément à l'index 0 reste inchangé.
Tri par ordre décroissant
Pour trier un tableau par ordre décroissant, nous pouvons utiliser la méthode Arrays.sort() avec Collections.reverseOrder() comme comparateur.
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 )); } }
Sortir
[4 3 2 -1] [chauhan Vishnu Hii]
Explication:
- Fonctionne uniquement sur les tableaux d'objets ; les types primitifs (int) ne peuvent pas utiliser de comparateurs.
- Pour les chaînes, le tri est lexicographique de Z -> A.
Tri personnalisé avec comparateur
Nous pouvons trier un tableau d'objets en définissant une logique de tri personnalisée à l'aide de l'outil Interface du comparateur .
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 ); } }
Sortir
1 Ram MP 2 Shyam UP 3 Hari Delhi
Explication:
- Comparator permet une logique de tri personnalisée sans modifier la classe.
- Ici, les étudiants sont triés par numéro de rôle.
Tri naturel avec interface comparable
Dans l'exemple ci-dessous, nous trions un tableau d'objets Student en fonction de leur nom par ordre alphabétique.
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 ); } }
Sortir
3 Hari Bihar 1 Ram UP 2 Shyam MP
Explication:
- Dans cet exemple, nous utilisons le Interface comparable pour définir un ordre naturel pour les objets Student.
- En implémentant la méthode, nous spécifions comment deux objets Student doivent être comparés en activant le tri basé sur le nom de l'étudiant.
Cela nous permet d'utiliser la méthode Arrays.sort() directement sur un tableau d'objets Student pour les trier dans un ordre et ici nous n'avons pas besoin d'un comparateur séparé.
