Découvrir les Collections

En Java, le framework Collections est une architecture unifiée pour représenter et manipuler des collections. Toutes les opérations de collections peuvent être effectuées à l’aide de ces classes.

Il existe plusieurs types de collections sous le framework Collections, notamment:

1. List : Il s’agit d’une collection ordonnée d’éléments qui peut contenir des éléments en double. Les éléments peuvent être insérés ou accédés par leur position dans la liste. Exemples de classes List : ArrayList, LinkedList, etc.

List<String> list = new ArrayList<>();
list.add("Element 1");
list.add("Element 2");

2. Set : Il s’agit d’une collection non ordonnée d’éléments uniques. Les éléments ne peuvent pas être accédés par leur position. Exemples de classes Set : HashSet, LinkedHashSet, TreeSet.

Set<String> set = new HashSet<>();
set.add("Element 1");
set.add("Element 2");

3. Queue : Il s’agit d’une collection d’éléments qui maintient l’ordre dans lequel les éléments ont été insérés. Elle est généralement utilisée pour la programmation concurrente. Exemples de classes Queue : PriorityQueue, ArrayDeque, LinkedList.

Queue<String> queue = new LinkedList<>();
queue.add("Element 1");
queue.add("Element 2");

4. Map : Il s’agit d’une collection d’éléments stockés sous forme de paires clé-valeur. Chaque clé est unique et est utilisée pour accéder à la valeur correspondante. Exemples de classes Map : HashMap, LinkedHashMap, TreeMap.

Map<String, String> map = new HashMap<>();
map.put("Clé 1", "Valeur 1");
map.put("Clé 2", "Valeur 2");

Chaque type de collection a ses propres caractéristiques et est utilisé dans différents scénarios en fonction des exigences.

Exemple pour ArrayList

créer un ArrayList en Java pour stocker l’évolution des baleines :

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

public class Main {
    public static void main(String[] args) {
        // Création d'un ArrayList pour stocker l'évolution des baleines
        List<String> evolutionBaleines = new ArrayList<>();

        // Ajout des étapes de l'évolution des baleines à l'ArrayList

        evolutionBaleines.add("Indohyus");
        evolutionBaleines.add("Cetace");
        evolutionBaleines.add("Pakicetus");
        evolutionBaleines.add("Ambulocetus");
        evolutionBaleines.add("Basilosaurus");
        evolutionBaleines.add("Dorudon");
        evolutionBaleines.add("Baleine");
        evolutionBaleines.add("Mysticetes (baleines à fanons)");
        evolutionBaleines.add("Mioscène (Rorqual)");

        // Affichage de l'évolution des baleines
        for (String etape : evolutionBaleines) {
            System.out.println(etape);
        }
    }
}

Dans cet exemple, nous créons un ArrayList appelé evolutionBaleines. Nous ajoutons ensuite chaque étape de l’évolution des baleines à la liste en utilisant la méthode add(). Enfin, nous utilisons une boucle for-each pour afficher chaque étape de l’évolution.

Collection intégrant des sous collections

voici comment vous pouvez créer une collection en Java qui contient des sous-collections. Dans cet exemple, chaque sous-collection représente une étape de l’évolution des baleines et contient les noms de quelques espèces de cette étape.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Création d'une HashMap pour stocker l'évolution des baleines
        Map<String, List<String>> evolutionBaleines = new HashMap<>();

        // Ajout des étapes de l'évolution des baleines à la HashMap
        evolutionBaleines.put("Artiodactyle", Arrays.asList("Hippopotame", "Girafe"));
        evolutionBaleines.put("Indohyus", Arrays.asList("Indohyus indirae"));
        evolutionBaleines.put("Cetace", Arrays.asList("Pakicetus", "Ambulocetus", "Basilosaurus"));
        evolutionBaleines.put("Dorudon", Arrays.asList("Dorudon atrox"));
        evolutionBaleines.put("Baleine", Arrays.asList("Baleine bleue", "Baleine à bosse"));
        evolutionBaleines.put("Mysticetes (baleines à fanons)", Arrays.asList("Rorqual bleu", "Rorqual commun"));
        evolutionBaleines.put("Rorqual", Arrays.asList("Rorqual boréal", "Rorqual tropical"));

        // Affichage de l'évolution des baleines
        for (Map.Entry<String, List<String>> entry : evolutionBaleines.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

Dans cet exemple, nous créons une HashMap appelée evolutionBaleines. Chaque entrée dans la HashMap est une paire clé-valeur où la clé est une étape de l’évolution des baleines et la valeur est une List contenant les noms de quelques espèces de cette étape. Enfin, nous utilisons une boucle for-each pour afficher chaque entrée de la HashMap.

Framework Collection

Les collections en Java sont un framework qui fournit une architecture pour stocker et manipuler des groupes d’objets. Les collections peuvent être utilisées pour effectuer des opérations telles que la recherche, le tri, l’insertion, la suppression et la manipulation de données. Le framework de collections de Java comprend plusieurs interfaces et classes qui peuvent être utilisées pour implémenter différentes structures de données, telles que des listes, des ensembles, des files d’attente et des cartes.

Les principales interfaces du framework de collections de Java sont Collection, List, Set, Queue et Map. Ces interfaces définissent les méthodes communes qui peuvent être utilisées pour manipuler des collections d’objets. Par exemple, l’interface Collection définit des méthodes telles que add, remove, contains et size qui peuvent être utilisées pour ajouter, supprimer, vérifier si un élément est présent et obtenir la taille d’une collection.

L’interface List étend l’interface Collection et représente une collection ordonnée d’éléments. Les éléments d’une liste peuvent être accédés par leur index et la liste peut contenir des éléments en double. Les classes qui implémentent l’interface List incluent ArrayList, LinkedList et Vector.

L’interface Set étend également l’interface Collection et représente une collection d’éléments uniques. Un ensemble ne peut pas contenir d’éléments en double. Les classes qui implémentent l’interface Set incluent HashSet, LinkedHashSet et TreeSet.

L’interface Queue étend l’interface Collection et représente une collection d’éléments qui suivent le principe du premier entré, premier sorti (FIFO). Les éléments sont ajoutés à la fin de la file d’attente et retirés du début. Les classes qui implémentent l’interface Queue incluent LinkedList, PriorityQueue et ArrayDeque.

L’interface Map ne fait pas partie de la hiérarchie de l’interface Collection, mais elle fait partie du framework de collections de Java. Une carte représente une collection d’associations clé-valeur où chaque clé est unique. Les classes qui implémentent l’interface Map incluent HashMap, LinkedHashMap, TreeMap et Hashtable.

Exercice :

Exercice : Gestion d'une collection de livres avec TreeSet

Contexte: Imaginez que vous avez une collection de livres. Chaque livre est représenté par son titre. Vous souhaitez stocker ces livres de manière à ce qu'ils soient toujours triés par ordre alphabétique et sans doublons.

Objectif: Utilisez un TreeSet pour stocker les titres des livres et effectuer les opérations suivantes :

1. Ajoutez les livres suivants à votre collection :

   • "L'étranger"
   • "La peste"
   • "1984"
   • "Le Meilleur des mondes"
   • "1984" (encore, pour tester l'unicité)

2. Affichez tous les livres dans l'ordre alphabétique.

3. Supprimez le livre "La peste" de la collection.

4. Affichez à nouveau tous les livres.

Solution:

import java.util.TreeSet;

public class GestionLivres {
    public static void main(String[] args) {
        TreeSet<String> collectionLivres = new TreeSet<>();

        // 1. Ajout de livres
        collectionLivres.add("L'étranger");
        collectionLivres.add("La peste");
        collectionLivres.add("1984");
        collectionLivres.add("Le Meilleur des mondes");
        collectionLivres.add("1984");  // Ceci ne sera pas ajouté car il est en double

        // 2. Afficher les livres
        System.out.println("Livres dans la collection:");
        for (String livre : collectionLivres) {
            System.out.println(livre);
        }

        // 3. Suppression d'un livre
        collectionLivres.remove("La peste");

        // 4. Afficher à nouveau les livres
        System.out.println("\nAprès suppression de 'La peste':");
        for (String livre : collectionLivres) {
            System.out.println(livre);
        }
    }
}

Résumé

les collections en Java fournissent un framework pour stocker et manipuler des groupes d’objets. Le framework comprend plusieurs interfaces et classes qui peuvent être utilisées pour implémenter différentes structures de données. Les principales interfaces du framework sont Collection, List, Set, Queue et Map. Ces interfaces définissent les méthodes communes qui peuvent être utilisées pour manipuler des collections d’objets.