Colección no genérica Vs genérica en Java

Discutiremos las diferencias más adelante, antes de comprender qué es la Colección genérica y la Colección no genérica, y lo más importante, tratar con la parte de implementación, ya que durante la implementación solo se puede obtener una comprensión real del concepto, de ahora en adelante las diferencias entre ellos.

Los genéricos son básicamente los errores que aparecen en tiempo de compilación que en tiempo de ejecución. Hay ciertas ventajas de los genéricos sobre los no genéricos que son las siguientes: 

1. Reutilización de código: con la ayuda de Generics, uno necesita escribir un método/clase/interfaz solo una vez y usarlo para cualquier tipo mientras que, en los no genéricos, el código debe escribirse una y otra vez cuando sea necesario.
2. Tipo de seguridad: los genéricos cometen errores que aparecen en tiempo de compilación que en tiempo de ejecución (siempre es mejor conocer los problemas en su código en tiempo de compilación en lugar de hacer que su código falle en tiempo de ejecución).

Ejemplo: Para crear un ArrayList que almacene el nombre de los estudiantes y si por error el programador agrega un objeto entero en lugar de una string, el compilador lo permite. Pero, cuando estos datos se recuperan de ArrayList, causan problemas en el tiempo de ejecución para ArrayList no genérico.

Implementación:

Ejemplo 1

// Java program to Demonstrate that Not Using Generics
// Can cause Run Time Exceptions
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an ArrayList
        // Declaring object without any type specified
        ArrayList al = new ArrayList();
 
        // Adding elements to the above object
        // Custom input elements
        al.add("Sachin");
        al.add("Rahul");
 
        // Compiler will allows this operation
        al.add(10);
 
        String s1 = (String)al.get(0);
        String s2 = (String)al.get(1);
 
        // Try block to check for exceptions
        try {
 
            // Causes Runtime Exception
            String s3 = (String)al.get(2);
        }
 
        // Catch block to handle the exceptions
        catch (Exception e) {
 
            // Display the exception
            System.out.println("Exception: " + e);
        }
    }
}

Producción: 

prog.java:19: warning: [unchecked] unchecked call to add(E) as a member of the raw type ArrayList
        al.add("Sachin");
              ^
  where E is a type-variable:
    E extends Object declared in class ArrayList
prog.java:20: warning: [unchecked] unchecked call to add(E) as a member of the raw type ArrayList
        al.add("Rahul");
              ^
  where E is a type-variable:
    E extends Object declared in class ArrayList
prog.java:23: warning: [unchecked] unchecked call to add(E) as a member of the raw type ArrayList
        al.add(10);
              ^
  where E is a type-variable:
    E extends Object declared in class ArrayList
3 warnings

¿Cómo resuelven los genéricos este problema?

Si esta lista se hiciera genérica, solo tomaría objetos de string y arrojaría un error de tiempo de compilación en cualquier otro caso.

Ejemplo 2

// Java Program to Illustrate Conversion of
// Runitime Exceptions into compile time errors
// Using generics
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an ArrayList
        // Declaring object of string type
        ArrayList<String> al = new ArrayList<String>();
 
        // Adding elements to the ArrayList
        // Custom input elements
        al.add("Sachin");
        al.add("Rahul");
 
        // Now compiler does not allow this operation
        al.add(10);
 
        String s1 = al.get(0);
        String s2 = al.get(1);
        String s3 = al.get(2);
    }
}

Producción:

prog.java:24: error: incompatible types: int cannot be converted to String
        al.add(10);
               ^
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error

Ahora, en el futuro, no se necesita fundición de tipo individual.

Si no se necesita Generics, entonces, en el ejemplo anterior, cada vez que los datos se van a recuperar de ArrayList, se deben encasillar. El encasillamiento en cada operación de recuperación es un gran dolor de cabeza. Esto se puede evitar si de alguna manera ya se sabe que la lista solo contiene datos de string.

Ejemplo 3

// Java program to Illustrate Type Casting is Needed
// Everytime in Non-Generic
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args) {
 
        // Creating an ArrayList
        // Declaring object without any type specified
        ArrayList al = new ArrayList();
 
        // Adding elements to the above object
        // using add() method
        al.add("Sachin");
        al.add("Rahul");
 
        // For every retrieval,
        // it needs to be casted to String for use
        String s1 = (String)al.get(0);
        String s2 = (String)al.get(1);
    }
}

Producción:

Geek , ahora deberías preguntarte cómo los genéricos resuelven este problema.

Si esta lista se hiciera genérica, solo tomaría objetos de string y devolvería solo objetos de string durante la recuperación. Y, por lo tanto, no se requerirá el encasillamiento individual. La afirmación anterior está justificada 

Ejemplo 4

// A Simple Java program to demonstrate that
// type casting is not needed in Generic
 
import java.util.*;
 
class Test {
    public static void main(String[] args)
    {
        // Creating an ArrayList
        // Declaring object of type String  
        ArrayList<String> al = new ArrayList<String>();
 
        // Custom input elements
        al.add("Sachin");
        al.add("Rahul");
 
        // Retrieval can be easily
        // without the trouble of casting
        String s1 = al.get(0);
        String s2 = al.get(1);
       
        // Print and display out the elements in objects
        System.out.print(al);
    }
}

[Sachin, Rahul]

Nota:

Con la ayuda de los genéricos, mientras que uno puede implementar algoritmos Implementando algoritmos genéricos, uno puede hacer que funcionen en diferentes tipos de objetos y al mismo tiempo también son seguros para el tipo.

Recuerde que hay algunos puntos que describirán la diferencia entre genéricos y no genéricos que se tabulan a continuación para obtener una comprensión clara entre ellos.