Generika der Java-Sammlung

Java-Sammlungsgenerika werden verwendet, um eine Möglichkeit in den angegebenen konkreten Typen hinzuzufügen, und es ist der allgemeine Zweck von Klassen und Methoden, die Objekte zum Ausführen und Abstrahieren betreiben, so dass sie auf einige typischere in den Sammlungen verwendete Objekte angewendet werden. Die Java-Generika mit anderen Klassen anstelle der Sammlungsklassen sind die einfachste Möglichkeit, die Grundlagen der Java-Generika zu zeigen. Dennoch ist es der schnellste Weg, die Grundlagen von Java-Generika mit Referenzierung und Dereferenzierung zu zeigen. Es verwendet Einstellungen für den generischen Typ einer Sammlung und andere Klassen wie HashSet, HashMap usw.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Übersicht über Java Collection Generics

Die Java-Generika sind für die Erstellung der Sortierung und ihrer Methode wichtiger; Es führt zuerst die Umwandlung durch und verwendet dann die Datentyp-Arrays wie Integer, String, char oder jedes andere Array, das die Reihenfolge in den Benutzerdaten unterstützt. Java-Programmierer verwenden generische Methoden und generische Klassen, um eine Gruppe verwandter Methoden mit bestimmten Typen in einer einzelnen Methodendeklaration mithilfe der Klassendeklaration zuzulassen und zu deklarieren. Generische Klassen bieten außerdem Sicherheit zu einem bestimmten Build-Zeitpunkt und ermöglichen es Programmierern, fehlerhafte Typen mit bestimmten Transformationen abzufangen. Darüber hinaus könnten wir eine generische Methode zum Sortieren eines Arrays von Objekten mithilfe der Java-Generic-Idee konstruieren, statt der generischen Methode, die Integer-Arrays, Double-Arrays, String-Arrays und andere Datentypfilter usw. verwendet, um den Array-Inhalt zu sortieren.

Verwendung generischer Sammlungen in Java

In der Programmiersprache Java sind die generischen Sammlungen am wichtigsten, da sie die Objekterstellung eines einzelnen Typs mithilfe der Typsicherheit ermöglichen. Wenn es sich bei dem Typ um Typsicherheit handelt, bedeutet dies, dass der Compiler die spezifischen Typen während der Kompilierungszeit validiert, auch wenn er den Fehler auslöst, wenn der Typwert nicht unterstützt wird. Angenommen, wir haben Typumwandlung verwendet, bedeutet dies, dass keine Umwandlung von Typen wie String, Integer, Double usw. erforderlich ist. Meistens werden die Generika für diesen Vorgang jedoch nicht benötigt, während wir ihn in der Anwendung ausgeführt haben. Vor den Generika konnten wir alle Objekte mit den angegebenen Sammlungen speichern, die sowohl generische als auch nicht-generische Typen sein können. Jetzt zwingen die Generika den Java-Codierer dazu, die Objekterstellung und ihre Vorgänge wie das Speichern und Abrufen der Werte aus den Objekten durchzuführen Backend bis Frontend. Wenn wir generische Sammlungen deaktivieren, sollten wir Typumwandlung verwenden, um das gewünschte Ergebnis zu erzielen, und es besteht keine Notwendigkeit für Typumwandlung im Kontext von Generika.

Die generischen Sammlungen verfügen über einige Standardmethoden, um die Funktionalität zu erreichen, die das Array von Objekten und die Sammlungen zum Einfügen und Abrufen der Daten aller Objekte in der Array-Sammlung benötigt. Wie in MapK, V> werden die generische Map-Schnittstelle (und die Map-Implementierungen) mit zwei parametrisierten Typen definiert. Der Typ jedes Schlüssels ist K und der Typ des mit einem Schlüssel verknüpften Werts ist V. Wir würden also MapString, Integer> um eine Karte zu speichern, die angibt, wie oft jedes Wort in einer Textdatei vorkommt. Wir würden MapString, ListInteger>> erstellen. wenn wir eine Karte benötigen, die die Zeilen definiert, in denen jedes Wort in einer Textdatei erscheint. Es ist erwähnenswert, dass wir generische Typinstanziierungen kombinieren (oder überlagern) können.

Vorteile von Java-Generika

Dies war eine schnelle Tour durch die wichtigsten Funktionen von Java-Generika. „Am entscheidendsten“ bezieht sich in diesem Zusammenhang auf „wichtiger im Vergleich zu allen anderen Sprachprogrammierern, die Generika verwenden“. Das Hauptziel besteht jedoch darin, über ausreichende Kenntnisse über Generika zu verfügen, um von anderen Programmen geschriebene Generika verwenden zu können. Anders gesagt; Wir müssen Generika gut genug verstehen, damit der Compiler unser Programm ohne Warnungen oder Fehler akzeptiert. Wenn Java unser Programm akzeptiert, sollte der generische Mechanismus seine Art von Sicherheit gewährleisten.

Typensicherheit ist einer der Vorteile und es kann nur ein Objekttyp gespeichert werden. Die Aufbewahrung anderer Gegenstände ist nicht möglich. Wir können jedes Objekt ohne Generics speichern.

Es ist nicht erforderlich, Typumwandlung zu verwenden, wenn das Objekt nicht typisiert werden muss.

Bevor wir Generics verwenden können, müssen wir zuerst die Werte typisieren und dann sollte Generics ausgeführt werden.

Überprüfung zur Kompilierungszeit stellt sicher, dass zur Laufzeit kein Problem auftritt. Gemäß dem hervorragenden Programmieransatz ist es wesentlich besser, das Problem zur Kompilierungszeit als zur Laufzeit zu lösen.

Beispiel #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());
}
}
}

Ausgabe:

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.

Das obige ist der detaillierte Inhalt vonGenerika der Java-Sammlung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!