Génériques de la collection Java

Les génériques de collection Java sont utilisés pour ajouter un chemin dans les types concrets spécifiés, et c'est l'objectif général des classes et des méthodes qui exploitent des objets pour l'exécuter et l'abstraire afin qu'il examine certains types plus généralement utilisés dans les collections. Les génériques Java avec d'autres classes plutôt que les classes de collection constituent le moyen le plus simple de montrer les bases des génériques Java. Pourtant, c’est le moyen le plus rapide de montrer les bases des génériques Java avec référencement et déréférencement. Il utilise des paramètres pour le type générique d'une collection et d'autres classes comme HashSet, HashMap, etc.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Présentation des génériques de la collection Java

Les génériques Java sont plus importants pour créer le tri et sa méthode ; il effectue d'abord la conversion, puis utilise les tableaux de types de données tels que Integer, String, char ou tout autre tableau prenant en charge le classement des données utilisateur. Les programmeurs Java utilisent des méthodes génériques et des classes génériques pour autoriser et déclarer un groupe de méthodes associées avec des types spécifiés dans une seule déclaration de méthode à l'aide de la déclaration de classe, respectivement. Les classes génériques assurent également la sécurité à un moment de construction spécifié, permettant aux programmeurs de détecter les types erronés avec des transformations particulières. De plus, nous pourrions construire une méthode générique pour trier un tableau d'objets en utilisant l'idée générique Java plutôt que la méthode générique utilisant des tableaux d'entiers, des tableaux doubles, des tableaux de chaînes et d'autres filtres de types de données, et ainsi de suite pour trier le contenu du tableau. 🎜>

Utilisations des collections génériques en Java

Dans le langage de programmation Java, les collections génériques sont les plus importantes, permettant la création d'objets d'un seul type en utilisant la sécurité des types. Si le type est Type safety, cela signifie que le compilateur validera les types spécifiques tout en utilisant le temps de compilation, même s'il générera l'erreur si la valeur du type n'est pas prise en charge. Si supposons que nous utilisions Type Casting, cela signifie qu'il n'est pas nécessaire de convertir les types tels que String, Integer, double, etc. Mais surtout, les génériques ne sont pas nécessaires pour cette opération pendant que nous l'effectuons dans l'application. Avant les génériques, nous pouvions stocker tous les objets avec les collections spécifiées qui peuvent être de n'importe quel type, à la fois générique et non générique. Désormais, les génériques obligeront le codeur Java à effectuer la création d'objets et ses opérations telles que le stockage et la récupération des valeurs du back-end vers le front-end. Si nous désactivons les collections génériques, nous devrions alors utiliser le transtypage pour obtenir le résultat souhaité, et il n'est pas nécessaire de transtyper dans le contexte des génériques.

Les collections génériques ont des méthodes par défaut pour obtenir la fonctionnalité qui prend le tableau d'objets et les collections pour placer et obtenir les données de tous les objets de la collection de tableaux. Comme dans MapK, V>, l'interface générique Map (et les implémentations de carte) sont définies avec deux types paramétrés. Le type de chaque clé est K et le type de valeur associée à une clé est V. Nous déclarons donc MapString, Integer> pour stocker une carte indiquant la fréquence à laquelle chaque mot apparaît dans un fichier texte. Nous créerions MapString, ListInteger>> si nous avions besoin d'une carte définissant les lignes sur lesquelles chaque mot apparaît dans un fichier texte. Il est à noter que nous pouvons combiner (ou superposer) des instanciations de type générique.

Avantages des génériques Java

Cela a été un tour d’horizon rapide des fonctionnalités les plus importantes des génériques Java. « Le plus crucial » dans ce contexte fait référence à « plus important par rapport à tous les autres programmeurs de langage qui utilisent des génériques ». Mais l’objectif principal est d’avoir suffisamment de connaissances sur les génériques pour pouvoir utiliser les génériques écrits par d’autres programmes. Autrement dit ; nous devons suffisamment bien comprendre les génériques pour que le compilateur accepte notre programme sans avertissements ni erreurs. Si Java accepte notre programme, le mécanisme générique devrait assurer son type de sécurité.

La sécurité des types est l'un des avantages, et elle ne peut stocker qu'un seul type d'objet. Il ne permet pas le stockage d'autres objets. Nous pouvons stocker n'importe quel objet sans génériques.

Il n'est pas nécessaire d'utiliser le transtypage lorsque l'objet n'a pas besoin d'être transtypé.

Avant de pouvoir utiliser les génériques, nous devons d'abord transtyper les valeurs, puis il doit exécuter les génériques.

La vérification au moment de la compilation garantit qu'aucun problème ne survient au moment de l'exécution. Selon l'excellente approche de programmation, il est considérablement préférable de gérer le problème au moment de la compilation qu'au moment de l'exécution.

Exemple n°1

Code :

import java.util.*;
class TestGenerics1{
public static void main(String args[]){
ArrayList<String> lst=new ArrayList<String>();
lst.add("January is the first month ");
lst.add("February is the second month");
lst.add("March is the third month");
lst.add("April is the fourth month");
lst.add("May is the fifth month");
lst.add("June is the sixth month ");
lst.add("July is the seventh month");
lst.add("August is the eigth month");
lst.add("September is the ninth month");
lst.add("October is the tenth month");
lst.add("November is the eleventh month");
lst.add("December is the twelth month");
String str=lst.get(7);
System.out.println("Welcome To My Domain its the first example: "+str);
Iterator<String> iterators=lst.iterator();
while(iterators.hasNext()){
System.out.println(iterators.next());
}
}
}

Sortie :

In the above example, we used Array List collection classes in the generics. With the help of add() method we can add n number of input values and get() method to retrieve the values.

Example #2

Code:

import java.util.*;
class TestGenerics1{
public static void main(String args[]){
Map<Integer,String> first=new HashMap<Integer,String>();
first.put(1,"Tv is the electronic device");
first.put(2,"Laptop is the electronic device");
first.put(3,"Computer is the electronic device");
first.put(4,"Mobile is the electronic device");
first.put(5,"Tablet is the electronic device");
Set<Map.Entry<Integer,String>> second=first.entrySet();
Iterator<Map.Entry<Integer,String>> iterators=second.iterator();
while(iterators.hasNext()){
Map.Entry<Integer, String>result=iterators.next();
System.out.println(result.getKey()+" "+result.getValue());
}
}}

Output:

In the above example, we used generic collections by using the Map interface. It contains some default and customized methods for achieving the operations. With the help of iterators, the values are listed on the loop.

Conclusion

Generally, it makes the programmer’s job easier and less error-prone when we use Java Generics. It’s a powerful addition to the Java language. It provides any correctness at compile time and, more crucially, implements generic algorithms without adding overhead to the Java programmers compared to the other language.

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!