Trier un tableau de chaînes par ordre alphabétique en Java

Mohammad Irfan 12 octobre 2023

Java Java String Java Array

Trier un tableau de chaînes sans utiliser de méthodes intégrées en Java
Trier un tableau de chaînes à l’aide de la méthode stringArraySort() en Java
Trier un tableau de chaînes à l’aide de la méthode compareTo() en Java
Trier un tableau de chaînes à l’aide de la méthode Arrays.sort() en Java
Trier un tableau de chaînes par ordre décroissant en Java
Trier un tableau de chaînes en ignorant la casse en Java
Trier un tableau de chaînes par ordre alphabétique en Java

Trier un tableau de chaînes par ordre alphabétique en Java

Ce didacticiel présente comment trier les tableaux de chaînes par ordre alphabétique en Java. Nous avons également répertorié quelques exemples de codes pour vous aider à comprendre le sujet.

Le tri consiste à organiser les données dans un ordre particulier. Nous pouvons trier les nombres entiers dans l’ordre croissant ou décroissant, ou nous pouvons trier les caractères ou les mots anglais dans l’ordre lexicographique.

L’ordre lexicographique est l’ordre dans lequel les mots apparaîtraient s’ils étaient présents dans un dictionnaire de mots anglais. Dans ce guide, nous vous apprendrons comment trier un tableau de chaînes en Java.

Nous comparerons des chaînes dans cet article avec des mots comme plus petit ou plus grand. Une chaîne est plus petite que l’autre si elle apparaît en premier selon l’ordre lexicographique.

De plus, dans l’ordre lexicographique, toutes les lettres majuscules précèdent les minuscules ; cela signifie qu’un mot commençant par Z sera présent avant un mot commençant par a dans un tableau trié.

Trier un tableau de chaînes sans utiliser de méthodes intégrées en Java

Nous allons d’abord essayer d’implémenter notre propre méthode de tri en Java. Nous allons créer une méthode appelée compareStrings(), qui compare deux chaînes et nous indique laquelle est la plus petite ou la plus grande.

Ensuite, nous comparerons chaque chaîne avec toutes les autres chaînes présentes dans le tableau en utilisant notre méthode compareStrings() et placerons cette chaîne dans sa position correcte. L’algorithme pour les deux méthodes est donné ci-dessous.

L’entrée de cette méthode sera constituée de deux chaînes et renverra une valeur entière. Le résultat de cette méthode est le suivant.
- Si string1 > string2 : renvoie un entier positif
- Si string1 < string2 : retourne un entier négatif
- Si string1 == string2 : renvoie 0
Nous allons parcourir simultanément chaque caractère des deux chaînes et comparer leurs valeurs Unicode. Nous utilisons la méthode intégrée charAt() pour obtenir les valeurs Unicode. Ces valeurs nous permettent de comparer des caractères comme s’il s’agissait d’entiers normaux.
Si les valeurs Unicode sont les mêmes pour les deux caractères, nous passerons au caractère suivant de chaque chaîne.
Si les valeurs Unicode diffèrent, nous renvoyons la différence des valeurs.
La boucle se termine lorsque nous n’avons plus de caractères dans l’une ou l’autre des chaînes.
Si les deux chaînes ont des longueurs différentes en dehors de la boucle, nous renvoyons cette différence. Nous faisons cela parce que tous les caractères de la chaîne la plus petite peuvent être présents au début de la plus longue. Par exemple, app et application. Dans ce cas, la chaîne la plus longue viendra après la plus petite.
Si les chaînes sont de même longueur, nous renverrons simplement 0, indiquant que les deux chaînes sont identiques.

Trier un tableau de chaînes à l’aide de la méthode `stringArraySort()` en Java

Cette méthode prend un tableau de chaînes en entrée et renvoie le tableau trié. Ici, nous aurons deux boucles, l’une imbriquée dans l’autre. Ils sont utilisés pour comparer chaque élément du tableau avec tous les éléments restants.

Nous les comparons à l’aide de notre méthode compareString() pour chaque paire d’éléments à l’intérieur de la boucle. Si la première chaîne est plus grande par rapport à l’autre, nous échangeons leurs positions.

Le code complet est indiqué ci-dessous.

public class Main {
  public static int compareStrings(String word1, String word2) {
    for (int i = 0; i < Math.min(word1.length(), word2.length()); i++) {
      if ((int) word1.charAt(i) != (int) word2.charAt(i)) // comparing unicode values
        return (int) word1.charAt(i) - (int) word2.charAt(i);
    }
    if (word1.length()
        != word2.length()) // smaller word is occurs at the beginning of the larger word
      return word1.length() - word2.length();
    else
      return 0;
  }
  public static String[] stringArraySort(String[] words) {
    for (int i = 0; i < words.length - 1; i++) {
      for (int j = i + 1; j < words.length; j++) {
        if (compareStrings(words[i], words[j]) > 0) // words[i] is greater than words[j]
        {
          String temp = words[i];
          words[i] = words[j];
          words[j] = temp;
        }
      }
    }
    return words;
  }
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    String[] sortedArr = stringArraySort(arrToSort);

    for (int i = 0; i < sortedArr.length; i++) System.out.print(sortedArr[i] + " ");
  }
}

Production:

Blueberry Strawberry apple bananas oranges

Trier un tableau de chaînes à l’aide de la méthode `compareTo()` en Java

Dans le code ci-dessus, nous avons écrit une méthode qui comparera deux chaînes et retournera une valeur entière pour indiquer quelle chaîne viendra en premier si elles étaient présentes dans un dictionnaire.

Java nous fournit une méthode intégrée appelée compareTo(), qui peut faire ce travail pour nous. La syntaxe de cette méthode est indiquée ci-dessous.

string1.compareTo(string2)

La sortie de cette méthode est similaire à la méthode compareStrings() que nous avons définie précédemment.

Si string1 > string2 : retourne un entier positif
Si string1 < string2 : retourne un entier négatif
Si string1 == string2 : retourne 0

Le code suivant montre comment fonctionne la méthode compareTo() en Java.

public class Main {
  public static void main(String[] args) {
    System.out.println("apple".compareTo("orange")); // apple < orange
    System.out.println("AAA".compareTo("aaa")); // AAA < aaa
    System.out.println("ZZZ".compareTo("aaa")); // ZZZ < aaa
    System.out.println("zzz".compareTo("aaa")); // zzz > aaa
    System.out.println("strawberry".compareTo("strawberry")); // strawberry == strawberry
  }
}

Production:

Nous pouvons utiliser la méthode compareTo() pour trier les tableaux. Ce programme sera très similaire au précédent ci-dessus. La seule différence est que nous utiliserons la méthode compareTo() au lieu de la méthode compareStrings() que nous avons définie précédemment.

public class Main {
  public static String[] stringArraySort(String[] words) {
    for (int i = 0; i < words.length - 1; i++) {
      for (int j = i + 1; j < words.length; j++) {
        if (words[i].compareTo(words[j]) > 0) // words[i] is greater than words[j]
        {
          String temp = words[i];
          words[i] = words[j];
          words[j] = temp;
        }
      }
    }
    return words;
  }
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    String[] sortedArr = stringArraySort(arrToSort);
    for (int i = 0; i < sortedArr.length; i++) System.out.print(sortedArr[i] + " ");
  }
}

Production:

 Blueberry Strawberry apple bananas oranges

Trier un tableau de chaînes à l’aide de la méthode `Arrays.sort()` en Java

Il existe un moyen encore plus simple de trier les tableaux. Nous pouvons utiliser la méthode sort() de la classe Arrays pour ce faire. La syntaxe de cette méthode est indiquée ci-dessous.

Arrays.sort(stringArray)

Par défaut, il triera le tableau dans l’ordre naturel (lexicographiquement). Cependant, nous pouvons modifier cet ordre en spécifiant différents comparateurs.

Un comparateur est une méthode utilisée pour comparer deux objets et nous dire lequel est plus petit ou plus grand que l’autre. La méthode sort() utilise l’algorithme Quicksort et a une complexité temporelle de O(n*log(n)).

Le code suivant montre le comportement par défaut de la méthode sort().

import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    Arrays.sort(arrToSort);
    for (int i = 0; i < arrToSort.length; i++) {
      System.out.print(arrToSort[i] + " ");
    }
  }
}

Production:

Blueberry Strawberry apple bananas oranges

Trier un tableau de chaînes par ordre décroissant en Java

Pour trier le tableau dans l’ordre naturel inverse ou l’ordre décroissant, nous pouvons utiliser le comparateur reverseOrder() comme indiqué ci-dessous.

import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    Arrays.sort(arrToSort, Collections.reverseOrder());
    for (int i = 0; i < arrToSort.length; i++) {
      System.out.print(arrToSort[i] + " ");
    }
  }
}

Production:

oranges bananas apple Strawberry Blueberry

Trier un tableau de chaînes en ignorant la casse en Java

Pour définir un tableau de chaînes dans l’ordre alphabétique mais ignorer la casse du caractère, utilisez cet exemple de code ci-dessous.

import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    Arrays.sort(arrToSort, String.CASE_INSENSITIVE_ORDER); // case insensitive sort
    for (int i = 0; i < arrToSort.length; i++) {
      System.out.print(arrToSort[i] + " ");
    }
  }
}

Production:

apple bananas Blueberry oranges Strawberry