Techniques de tri en Java

Introduction

Le tri est une opération essentielle en informatique, et Java propose diverses méthodes intégrées pour trier différentes structures de données. Java met à disposition plusieurs classes permettant de trier ces structures. Dans ce laboratoire, nous explorerons le tri des tableaux, des collections et des instances de classes définies par l'utilisateur.

Tri des tableaux

Les tableaux sont une structure de données simple utilisée pour stocker des types de données similaires de manière ordonnée. Nous pouvons trier les tableaux en utilisant la méthode intégrée sort() de la classe Arrays.

Créez ou remplacez le fichier Sorting.java dans le répertoire ~/project avec le code suivant :

import java.util.Arrays;

public class Sorting {
    public static void main(String[] args) {
        int[] arr = {7, 9, 1, 0, 2, 5, 6, 11};
        System.out.println("Array Before Sorting: " + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("Array After Sorting: " + Arrays.toString(arr));
    }
}

Pour exécuter ce code, accédez au répertoire ~/project dans le terminal et exécutez les commandes suivantes :

javac Sorting.java
java Sorting

Ce code triera le tableau par ordre croissant. Si vous souhaitez trier un tableau par ordre décroissant, vous devez utiliser l'interface Comparator.

Tri des collections

Java fournit la classe Collections qui dispose d'une méthode sort() pour trier les collections telles que les listes, les ensembles et les tables de correspondance (maps). Le fonctionnement de cette fonction est similaire à celui de la méthode sort() de la classe Arrays.

Créez ou remplacez le fichier Sorting.java dans le répertoire ~/project avec le code suivant :

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Sorting {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(6);
        list.add(3);
        list.add(8);
        list.add(1);
        list.add(9);

        System.out.println("List before sorting: " + list);

        Collections.sort(list);
        System.out.println("List after sorting: " + list);
    }
}

Pour exécuter ce code, accédez au répertoire ~/project dans le terminal et exécutez les commandes suivantes :

javac Sorting.java
java Sorting

Tri des ensembles (Sets)

Les ensembles sont utilisés pour stocker des données non ordonnées sans doublons. Nous ne pouvons pas trier les ensembles directement en utilisant la méthode sort() de la classe Collections. Cependant, nous pouvons visualiser les données triées en transférant tous les éléments de l'ensemble vers une liste, puis en triant cette liste.

Créez ou remplacez le fichier Sorting.java dans le répertoire ~/project avec le code suivant :

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Sorting {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<Integer>();
        set.add(6);
        set.add(3);
        set.add(-2);
        set.add(1);
        set.add(9);

        List<Integer> list = new ArrayList<Integer>(set);
        Collections.sort(list);
        System.out.println("Set after sorting: " + list);
    }
}

Pour exécuter ce code, accédez au répertoire ~/project dans le terminal et exécutez les commandes suivantes :

javac Sorting.java
java Sorting

Le résultat de ce code sera une liste d'entiers triée.

Tri des tables de correspondance (Maps)

Les tables de correspondance (maps) sont utilisées pour stocker des paires clé-valeur. Nous pouvons trier les maps en fonction de leurs clés ou de leurs valeurs. La classe TreeMap peut également être utilisée pour stocker des paires clé-valeur dans un ordre trié.

Créez ou remplacez le fichier Sorting.java dans le répertoire ~/project avec le code suivant :

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class Sorting {
    public static void main(String[] args) {
        Map<Integer, String> map = new TreeMap<Integer, String>();
        map.put(6, "Apple");
        map.put(3, "Banana");
        map.put(1, "Mango");
        map.put(9, "Orange");

        System.out.println("Map before sorting: " + map);

        // Sorting by keys
        Map<Integer, String> sortedByKeyMap = new TreeMap<Integer, String>(map);
        System.out.println("Map after sorting by keys: " + sortedByKeyMap);

        // Sorting by value
        List<Map.Entry<Integer, String>> list = new ArrayList<Map.Entry<Integer, String>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
            public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });

        Map<Integer, String> sortedByValueMap = new LinkedHashMap<Integer, String>();
        for (Map.Entry<Integer, String> entry : list) {
            sortedByValueMap.put(entry.getKey(), entry.getValue());
        }
        System.out.println("Map after sorting by values: " + sortedByValueMap);
    }
}

Pour exécuter ce code, accédez au répertoire ~/project dans le terminal et exécutez les commandes suivantes :

javac Sorting.java
java Sorting

Ce code triera la map par ses clés et par ses valeurs.

Résumé

Ce laboratoire a démontré comment trier différentes structures de données en Java. Nous avons appris à trier des tableaux, des collections et des maps. Nous avons également appris à trier des objets de classes définies par l'utilisateur en utilisant les interfaces Comparable et Comparator. La méthode sort() des classes Collections et Arrays a été utilisée pour trier les listes et les tableaux. Enfin, nous avons appris à trier les maps en fonction de leurs valeurs et de leurs clés.