IL Generici Java la programmazione è stata introdotta in J2SE 5 per gestire oggetti indipendenti dai tipi. Rende il codice stabile rilevando i bug in fase di compilazione.

formato stringa in Java

Prima dei generici, possiamo archiviare qualsiasi tipo di oggetto nella raccolta, ovvero non generico. Ora i generici costringono il programmatore Java a memorizzare un tipo specifico di oggetti.

Vantaggio dei generici Java

Ci sono principalmente 3 vantaggi dei farmaci generici. Sono i seguenti:

1) Sicurezza del tipo: Possiamo contenere solo un singolo tipo di oggetti nei generici. Non consente di riporre altri oggetti.

Senza Generics, possiamo archiviare qualsiasi tipo di oggetto.

 List list = new ArrayList(); list.add(10); list.add('10'); With Generics, it is required to specify the type of object we need to store. List list = new ArrayList(); list.add(10); list.add('10');// compile-time error 

2) Il casting del tipo non è richiesto: Non è necessario eseguire il typecast dell'oggetto.

Prima di Generics, dobbiamo digitare cast.

 List list = new ArrayList(); list.add('hello'); String s = (String) list.get(0);//typecasting After Generics, we don't need to typecast the object. List list = new ArrayList(); list.add('hello'); String s = list.get(0); 

3) Controllo in fase di compilazione: Viene controllato in fase di compilazione, quindi il problema non si verificherà in fase di esecuzione. Una buona strategia di programmazione afferma che è molto meglio gestire il problema in fase di compilazione piuttosto che in fase di esecuzione.

 List list = new ArrayList(); list.add('hello'); list.add(32);//Compile Time Error 

Sintassi per utilizzare la raccolta generica

 ClassOrInterface 

Esempio per utilizzare i generici in Java

 ArrayList 

Esempio completo di generici in Java

Qui stiamo utilizzando la classe ArrayList, ma puoi utilizzare qualsiasi classe di raccolta come ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator ecc.

stringa di suddivisione c++

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 element is: jai rahul jai 

Esempio di Java Generics che utilizza Map

Ora utilizzeremo gli elementi della mappa utilizzando i generici. Qui, dobbiamo passare chiave e valore. Cerchiamo di capirlo con un semplice esempio:

 import java.util.*; class TestGenerics2{ public static void main(String args[]){ Map map=new HashMap(); map.put(1,&apos;vijay&apos;); map.put(4,&apos;umesh&apos;); map.put(2,&apos;ankit&apos;); //Now use Map.Entry for Set and Iterator Set<map.entry> set=map.entrySet(); Iterator<map.entry> itr=set.iterator(); while(itr.hasNext()){ Map.Entry e=itr.next();//no need to typecast System.out.println(e.getKey()+&apos; &apos;+e.getValue()); } }} </map.entry></map.entry>

Produzione

 1 vijay 2 ankit 4 umesh 

Classe generica

Una classe che può fare riferimento a qualsiasi tipo è nota come classe generica. Qui stiamo utilizzando il parametro di tipo T per creare la classe generica di tipo specifico.

Vediamo un semplice esempio per creare ed utilizzare la classe generica.

Creazione di una classe generica:

 class MyGen{ T obj; void add(T obj){this.obj=obj;} T get(){return obj;} } 

Il tipo T indica che può fare riferimento a qualsiasi tipo (come String, Integer e Employee). Il tipo specificato per la classe verrà utilizzato per archiviare e recuperare i dati.

Utilizzando la classe generica:

Vediamo il codice per utilizzare la classe generica.

 class TestGenerics3{ public static void main(String args[]){ MyGen m=new MyGen(); m.add(2); //m.add('vivek');//Compile time error System.out.println(m.get()); }} 

Produzione

 2 

Digitare Parametri

Le convenzioni di denominazione dei parametri di tipo sono importanti per apprendere a fondo i generici. I parametri di tipo comuni sono i seguenti:

floppy disk

1. T - Tipo
2. E - Elemento
3. K - Chiave
4. N - Numero
5. V - Valore

Metodo generico

Come la classe generica, possiamo creare un metodo generico che possa accettare qualsiasi tipo di argomento. In questo caso, l'ambito degli argomenti è limitato al metodo in cui è dichiarato. Consente metodi statici e non statici.

Vediamo un semplice esempio di metodo generico Java per stampare gli elementi dell'array. Stiamo usando qui E per denotare l'elemento.

 public class TestGenerics4{ public static void printArray(E[] elements) { for ( E element : elements){ System.out.println(element ); } System.out.println(); } public static void main( String args[] ) { Integer[] intArray = { 10, 20, 30, 40, 50 }; Character[] charArray = { 'J', 'A', 'V', 'A', 'T','P','O','I','N','T' }; System.out.println( 'Printing Integer Array' ); printArray( intArray ); System.out.println( 'Printing Character Array' ); printArray( charArray ); } } 

Produzione

 Printing Integer Array 10 20 30 40 50 Printing Character Array J A V A T P O I N T 

Caratteri jolly nei generici Java

IL ? (punto interrogativo) rappresenta l'elemento jolly. Significa qualsiasi tipo. Se scriviamo , significa qualsiasi classe figlia di Number, ad esempio Integer, Float e double. Ora possiamo chiamare il metodo della classe Number attraverso qualsiasi oggetto della classe figlio.

Possiamo usare un carattere jolly come a tipo di parametro, campo, tipo restituito o variabile locale. Tuttavia, non è consentito utilizzare un carattere jolly come argomento di tipo per l'invocazione di un metodo generico, la creazione di un'istanza di classe generica o un supertipo .

Capiamolo con l'esempio riportato di seguito:

 import java.util.*; abstract class Shape{ abstract void draw(); } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle');} } class GenericTest{ //creating a method that accepts only child class of Shape public static void drawShapes(List lists){ for(Shape s:lists){ s.draw();//calling method of Shape class by child class instance } } public static void main(String args[]){ List list1=new ArrayList(); list1.add(new Rectangle()); List list2=new ArrayList(); list2.add(new Circle()); list2.add(new Circle()); drawShapes(list1); drawShapes(list2); }} 

Produzione

 drawing rectangle drawing circle drawing circle 

Caratteri jolly con limite superiore

Lo scopo dei caratteri jolly con limite superiore è ridurre le restrizioni su una variabile. Limita il tipo sconosciuto a essere un tipo specifico o un sottotipo di quel tipo. Viene utilizzato dichiarando un carattere jolly ('?') seguito dalla parola chiave extends (in caso di classe) o implements (in caso di interfaccia), seguita dal suo limite superiore.

Sintassi

 List 

Qui,

tostring java

? è un carattere jolly.

si estende , è una parola chiave.

Numero , è una classe presente nel pacchetto java.lang

Supponiamo di voler scrivere il metodo per l'elenco di Number e i suoi sottotipi (come Integer, Double). Utilizzando Elenco è adatto per un elenco di tipo Number o una qualsiasi delle sue sottoclassi mentre Elenco funziona solo con l'elenco di tipo Numero. COSÌ, Elenco è meno restrittivo di Elenco .

Esempio di carattere jolly limite superiore

In questo esempio, utilizziamo i caratteri jolly del limite superiore per scrivere il metodo per List e List.

 import java.util.ArrayList; public class UpperBoundWildcard { private static Double add(ArrayList num) { double sum=0.0; for(Number n:num) { sum = sum+n.doubleValue(); } return sum; } public static void main(String[] args) { ArrayList l1=new ArrayList(); l1.add(10); l1.add(20); System.out.println('displaying the sum= '+add(l1)); ArrayList l2=new ArrayList(); l2.add(30.0); l2.add(40.0); System.out.println('displaying the sum= '+add(l2)); } } 

Produzione

 displaying the sum= 30.0 displaying the sum= 70.0 

Caratteri jolly illimitati

Il tipo jolly illimitato rappresenta l'elenco di un tipo sconosciuto come List. Questo approccio può essere utile nei seguenti scenari: -

• Quando il metodo specificato viene implementato utilizzando la funzionalità fornita nella classe Object.
• Quando la classe generica contiene i metodi che non dipendono dal parametro type.

Esempio di caratteri jolly illimitati

 import java.util.Arrays; import java.util.List; public class UnboundedWildcard { public static void display(List list) { for(Object o:list) { System.out.println(o); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); display(l1); List l2=Arrays.asList('One','Two','Three'); System.out.println('displaying the String values'); display(l2); } } 

Produzione

 displaying the Integer values 1 2 3 displaying the String values One Two Three 

Caratteri jolly con limite inferiore

Lo scopo dei caratteri jolly con limite inferiore è limitare il tipo sconosciuto a un tipo specifico o a un supertipo di quel tipo. Viene utilizzato dichiarando il carattere jolly ('?') seguito dalla parola chiave super, seguita dal suo limite inferiore.

Sintassi

 List 

Qui,

? è un carattere jolly.

super , è una parola chiave.

Numero intero , è una classe wrapper.

espressione regolare Java per

Supponiamo di voler scrivere il metodo per la lista di Integer e il suo supertipo (come Number, Object). Utilizzando Elenco è adatto per un elenco di tipo Integer o una qualsiasi delle sue superclassi mentre Elenco funziona solo con l'elenco di tipo Integer. COSÌ, Elenco è meno restrittivo di Elenco .

Esempio di carattere jolly limite inferiore

In questo esempio, utilizziamo i caratteri jolly del limite inferiore per scrivere il metodo per List e List.

 import java.util.Arrays; import java.util.List; public class LowerBoundWildcard { public static void addNumbers(List list) { for(Object n:list) { System.out.println(n); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); addNumbers(l1); List l2=Arrays.asList(1.0,2.0,3.0); System.out.println('displaying the Number values'); addNumbers(l2); } } 

Produzione

 displaying the Integer values 1 2 3 displaying the Number values 1.0 2.0 3.0