El Genéricos de Java La programación se introduce en J2SE 5 para tratar con objetos de tipo seguro. Hace que el código sea estable al detectar errores en el momento de la compilación.

fecha y hora mecanografiadas

Antes de los genéricos, podemos almacenar cualquier tipo de objetos en la colección, es decir, no genéricos. Ahora los genéricos obligan al programador de Java a almacenar un tipo específico de objetos.

Ventaja de los genéricos de Java

Existen principalmente 3 ventajas de los genéricos. Son los siguientes:

1) Tipo de seguridad: Solo podemos contener un único tipo de objetos en genéricos. No permite almacenar otros objetos.

Sin Generics, podemos almacenar cualquier tipo de objetos.

 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) No se requiere fundición tipográfica: No es necesario encasillar el objeto.

Antes de Genéricos, debemos escribir 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) Comprobación en tiempo de compilación: Se verifica en tiempo de compilación para que no se produzcan problemas en tiempo de ejecución. Una buena estrategia de programación dice que es mucho mejor manejar el problema en tiempo de compilación que en tiempo de ejecución.

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

Sintaxis usar colección genérica

 ClassOrInterface 

Ejemplo usar genéricos en java

 ArrayList 

Ejemplo completo de genéricos en Java

Aquí, estamos usando la clase ArrayList, pero puede usar cualquier clase de colección como ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator, etc.

identificadores válidos de java

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

Producción:

 element is: jai rahul jai 

Ejemplo de genéricos de Java utilizando Map

Ahora vamos a utilizar elementos del mapa usando genéricos. Aquí necesitamos pasar la clave y el valor. Entendámoslo con un ejemplo sencillo:

 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>

Producción

 1 vijay 2 ankit 4 umesh 

clase genérica

Una clase que puede hacer referencia a cualquier tipo se conoce como clase genérica. Aquí, estamos usando el parámetro de tipo T para crear la clase genérica de un tipo específico.

Veamos un ejemplo sencillo para crear y utilizar la clase genérica.

Creando una clase genérica:

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

El tipo T indica que puede hacer referencia a cualquier tipo (como String, Integer y Employee). El tipo que especifique para la clase se utilizará para almacenar y recuperar los datos.

Usando clase genérica:

Veamos el código para usar la clase genérica.

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

Producción

 2 

Tipo de parámetros

Las convenciones de nomenclatura de los parámetros de tipo son importantes para aprender a fondo los genéricos. Los parámetros de tipo comunes son los siguientes:

Python de búsqueda binaria

1. T - Tipo
2. E-elemento
3. K - clave
4. norte - número
5. V - Valor

Método genérico

Al igual que la clase genérica, podemos crear un método genérico que pueda aceptar cualquier tipo de argumentos. Aquí, el alcance de los argumentos se limita al método donde se declara. Permite métodos estáticos y no estáticos.

Veamos un ejemplo simple de un método genérico de Java para imprimir elementos de una matriz. Estamos usando aquí Y para denotar el 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 ); } } 

Producción

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

Comodín en genéricos de Java

El ? El símbolo (signo de interrogación) representa el elemento comodín. Quiere decir cualquier tipo. Si escribimos, significa cualquier clase secundaria de Número, por ejemplo, Integer, Float y double. Ahora podemos llamar al método de la clase Número a través de cualquier objeto de clase secundaria.

Podemos utilizar un comodín como tipo de parámetro, campo, tipo de retorno o variable local. Sin embargo, no está permitido utilizar un comodín como argumento de tipo para la invocación de un método genérico, la creación de una instancia de clase genérica o un supertipo. .

Entendámoslo con el ejemplo que se da a continuación:

 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); }} 

Producción

 drawing rectangle drawing circle drawing circle 

Comodines de límite superior

El propósito de los comodines de límite superior es disminuir las restricciones de una variable. Restringe el tipo desconocido a un tipo específico o un subtipo de ese tipo. Se utiliza declarando el carácter comodín ('?') seguido de la palabra clave extends (en el caso de, clase) o implements (en el caso de, interfaz), seguida de su límite superior.

Sintaxis

 List 

Aquí,

ordenar una lista de matrices java

? es un carácter comodín.

se extiende , es una palabra clave.

Número , es una clase presente en el paquete java.lang

Supongamos que queremos escribir el método para la lista de Números y sus subtipos (como Integer, Double). Usando Lista es adecuado para una lista de tipo Número o cualquiera de sus subclases, mientras que Lista funciona solo con la lista de tipo Número. Entonces, Lista es menos restrictivo que Lista .

Ejemplo de comodín de límite superior

En este ejemplo, utilizamos los comodines de límite superior para escribir el método para Lista y Lista.

 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)); } } 

Producción

 displaying the sum= 30.0 displaying the sum= 70.0 

Comodines ilimitados

El tipo comodín ilimitado representa la lista de un tipo desconocido como Lista. Este enfoque puede resultar útil en los siguientes escenarios: -

• Cuando el método dado se implementa utilizando la funcionalidad proporcionada en la clase Objeto.
• Cuando la clase genérica contiene métodos que no dependen del parámetro de tipo.

Ejemplo de comodines ilimitados

 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); } } 

Producción

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

Comodines de límite inferior

El propósito de los comodines de límite inferior es restringir el tipo desconocido para que sea un tipo específico o un supertipo de ese tipo. Se utiliza declarando el carácter comodín ('?') seguido de la palabra clave super, seguido de su límite inferior.

Sintaxis

 List 

Aquí,

? es un carácter comodín.

súper , es una palabra clave.

Entero , es una clase contenedora.

regexp_like en mysql

Supongamos que queremos escribir el método para la lista de números enteros y su supertipo (como Número, Objeto). Usando Lista es adecuado para una lista de tipo Integer o cualquiera de sus superclases, mientras que Lista funciona solo con la lista de tipo Integer. Entonces, Lista es menos restrictivo que Lista .

Ejemplo de comodín de límite inferior

En este ejemplo, utilizamos los comodines de límite inferior para escribir el método para Lista y Lista.

 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); } } 

Producción

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