Génériques de pièces dans les méthodes de collections, de tri et d'utilitaires

Dans cet article de suivi, nous nous concentrerons entièrement sur les Génériques dans les collections, le concept de sécurité des types dans les collections Java et la manière dont les génériques créent votre code. plus flexible et robuste. De plus, nous explorerons le fonctionnement du tri avec les collections génériques et certaines méthodes utilitaires avancées qui s'avèrent utiles.

—

Table des matières

1. Introduction aux génériques
2. Génériques dans les listes
3. Génériques en ensembles
4. Génériques dans Maps
5. Tri avec les génériques
6. Méthodes utilitaires avancées
7. Erreurs courantes liées aux génériques
8. Défis
9. Conclusion

—

Introduction aux génériques

Les

Génériques en Java vous permettent d'écrire une classe, une interface ou une méthode qui fonctionne avec n'importe quel type de données. En utilisant des génériques avec des collections, vous garantissez la sécurité des types au moment de la compilation. Cela signifie que vous pouvez éviter les erreurs potentielles ClassCastException et éliminer le besoin de conversion explicite.

Par exemple :

List<String> strings = new ArrayList<>();
strings.add("Hello");
// Adding a non-String value will now cause a compile-time error.

Les génériques garantissent que seul le type de données spécifié peut être stocké dans la collection, évitant ainsi les problèmes d'exécution et rendant le code plus lisible et maintenable.

—

Génériques dans les listes

Les génériques dans les listes garantissent que vous ne pouvez stocker que des objets du type spécifié. Par exemple, Liste autorise uniquement les objets String, tandis que List autorise uniquement les objets entiers.

Exemple de code

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

public class GenericListExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");

        // The following line would cause a compile-time error:
        // names.add(123); // Error: cannot add Integer to List<String>

        for (String name : names) {
            System.out.println(name);
        }
    }
}

Avantages

• Sécurité des types : le compilateur imposera que seuls les objets du type déclaré puissent être ajoutés à la liste.
• Pas de casting explicite : Pas besoin de cast lors de la récupération d'éléments de la liste.

—

Génériques dans les ensembles

Les ensembles avec des génériques fonctionnent de la même manière que les listes, garantissant que tous les éléments sont d'un type spécifique.

Exemple de code

import java.util.HashSet;
import java.util.Set;

public class GenericSetExample {
    public static void main(String[] args) {
        Set<Integer> numbers = new HashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Compile-time error if a non-Integer is added:
        // numbers.add("forty"); // Error

        for (Integer num : numbers) {
            System.out.println(num);
        }
    }
}

Avantages

• Vous conservez le caractère unique des éléments de manière sécurisée.
• Garantit qu'aucun type involontaire n'est ajouté.

—

Génériques dans Maps

Les cartes, étant des paires clé-valeur, prennent en charge les génériques pour la clé et la valeur. Par exemple, Map imposera que les clés soient des chaînes et que les valeurs soient entières.

Exemple de code

import java.util.HashMap;
import java.util.Map;

public class GenericMapExample {
    public static void main(String[] args) {
        Map<String, Integer> phoneBook = new HashMap<>();
        phoneBook.put("Alice", 12345);
        phoneBook.put("Bob", 67890);

        // The following would cause a compile-time error:
        // phoneBook.put(123, "Charlie"); // Error

        for (Map.Entry<String, Integer> entry : phoneBook.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Avantages

• Vous pouvez garantir la sécurité des types pour les clés et les valeurs de la carte.
• Empêche les erreurs d'exécution potentielles dues au mélange des types.

—

Trier avec des génériques

Le tri des collections génériques est simple et s'effectue à l'aide de Collections.sort() pour les listes et de Comparable ou Comparator pour le tri personnalisé.

Exemple de code

List<String> strings = new ArrayList<>();
strings.add("Hello");
// Adding a non-String value will now cause a compile-time error.

Pour un tri personnalisé, vous pouvez implémenter l'interface Comparator.

—

Méthodes utilitaires avancées

La classe utilitaire Collections prend également en charge des opérations telles que recherche binaire, shuffle, inverse et comptage de fréquence. Ces opérations peuvent être appliquées à des collections génériques pour une manipulation de données plus puissante.

Exemple de code

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

public class GenericListExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");

        // The following line would cause a compile-time error:
        // names.add(123); // Error: cannot add Integer to List<String>

        for (String name : names) {
            System.out.println(name);
        }
    }
}

—

Erreurs courantes liées aux génériques

• Utilisation de types bruts : spécifiez toujours le paramètre de type lors de l'utilisation de collections pour éviter d'éventuels problèmes d'exécution.

import java.util.HashSet;
import java.util.Set;

public class GenericSetExample {
    public static void main(String[] args) {
        Set<Integer> numbers = new HashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Compile-time error if a non-Integer is added:
        // numbers.add("forty"); // Error

        for (Integer num : numbers) {
            System.out.println(num);
        }
    }
}

• Utilisation incorrecte des caractères génériques : lors de la transmission de collections aux méthodes, l'utilisation de caractères génériques tels que List ou Liste peut prêter à confusion. Comprendre quand utiliser ? et les mots-clés extends ou super.

—

Défis

Défi 1 : pile générique

Implémentez une classe de pile simple en utilisant des génériques. La pile doit prendre en charge le fait de pousser des éléments, de faire apparaître des éléments et de vérifier si elle est vide.

Défi 2 : Trier les objets personnalisés

Créez une liste d'objets personnalisés, tels que Personne, et triez-la en fonction d'un champ personnalisé tel que l'âge ou le nom.

—

Conclusion

Dans cet article, nous avons exploré comment utiliser les Génériques dans les collections pour la sécurité des types, la flexibilité et la facilité d'utilisation. Nous avons également discuté du tri et des méthodes utilitaires avancées qui rendent le travail avec les collections plus efficace. En maîtrisant les génériques, vous pouvez écrire du code plus robuste, sans erreur et hautement réutilisable.

—

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!