L'application des génériques Java pour résoudre des problèmes courants en Java

Les génériques résolvent deux problèmes courants en Java : Code en double : élimine le besoin d'écrire du code spécifique pour chaque type de données, comme la création d'une liste triée de différents types. Flexibilité insuffisante : permet au code de s'adapter facilement aux changements liés à l'utilisation de différents types de données, comme l'utilisation de files d'attente génériques pour stocker et récupérer divers éléments.

Java Generics : un outil puissant pour résoudre les problèmes courants

Les génériques sont un outil puissant en Java qui vous permet de créer du code qui fonctionne avec une variété de types de données. En utilisant des génériques, vous pouvez éliminer les erreurs de code en double, augmenter la flexibilité et rendre le code plus robuste.

Problème : Code en double

Sans utiliser de génériques, un code spécifique doit être écrit pour chaque type de données à traiter, ce qui entraîne un code en double et une charge de maintenance supplémentaire. Par exemple, pour créer une liste triée de types Integer et String, vous devrez écrire deux méthodes distinctes : Integer 和 String 的列表，您需要編寫兩個單獨的方法：

List<Integer> integerList = new ArrayList<>();
integerList.add(10);
integerList.add(5);
Collections.sort(integerList);

List<String> stringList = new ArrayList<>();
stringList.add("John");
stringList.add("Mary");
Collections.sort(stringList);

泛型解決方案：

使用泛型，您可以定義一個通用方法來處理任何類型的列表：

public static <T extends Comparable<T>> void sortList(List<T> list) {
    Collections.sort(list);
}

泛型類型參數 T 指定列表中的元素將實現 Comparable 介面，從而能夠按其自然順序進行比較。現在，您可以使用泛型方法為任何類型的列表排序：

List<Integer> integerList = new ArrayList<>();
sortList(integerList);

List<String> stringList = new ArrayList<>();
sortList(stringList);

問題：靈活性不足

不使用泛型，代碼無法輕鬆適應需要處理不同數據類型的變化。例如，如果您需要將 ArrayBlockingQueue 用於 Integer 和 String，您需要創建兩個單獨的佇列：

ArrayBlockingQueue<Integer> integerQueue = new ArrayBlockingQueue<>(10);
integerQueue.put(10);

ArrayBlockingQueue<String> stringQueue = new ArrayBlockingQueue<>(10);
stringQueue.put("John");

泛型解決方案：

使用泛型，您可以定義一個通用佇列，可容納任何類型的元素：

public class GenericQueue<T> {
    private Queue<T> queue;

    public GenericQueue() {
        queue = new ArrayBlockingQueue<>(10);
    }

    public void put(T element) {
        queue.offer(element);
    }

    public T take() {
        return queue.poll();
    }
}

泛型類型參數 T

GenericQueue<Integer> integerQueue = new GenericQueue<>();
integerQueue.put(10);
int element = integerQueue.take();

GenericQueue<String> stringQueue = new GenericQueue<>();
stringQueue.put("John");
String element = stringQueue.take();

Solution générique :

rrreee
• Le paramètre de type générique T spécifie que les éléments de la liste implémenteront l'interface Comparable, cela permet comparaisons à faire dans leur ordre naturel. Vous pouvez désormais utiliser des méthodes génériques pour trier n'importe quel type de liste :
rrreee
• Problème : Flexibilité insuffisante
• Sans utiliser de génériques, le code ne peut pas facilement s'adapter aux changements qui nécessitent la gestion de différents types de données. Par exemple, si vous devez utiliser ArrayBlockingQueue pour Integer et String, vous devez créer deux files d'attente distinctes :
rrreee

Solution générique :

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!