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

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] 

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).

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] 

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.

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] 

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 .

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 

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.

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 

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é.