pila genérica
genérico
que es generico
Generics es un concepto utilizado en los lenguajes de programación que permite utilizar uno o más parámetros de tipo a la hora de definir una clase, interfaz o método. Mediante el uso de genéricos, puede escribir código genérico que funcione en diferentes tipos de datos, mejorando la reutilización del código y la seguridad de los tipos.
Los beneficios de los genéricos
1. Seguridad de tipos: mediante el uso de genéricos, los errores de tipo pueden detectarse en tiempo de compilación en lugar de errores en tiempo de ejecución.
2. Reutilización de código: el código común se puede escribir y compartir entre diferentes tipos, lo que reduce la escritura de código redundante.
3. Optimización del rendimiento: dado que el código genérico es de tipo seguro, el compilador puede optimizar un tipo específico para mejorar el rendimiento del código.
Por ejemplo, en Java, puede usar genéricos para definir un contenedor de lista de propósito general y especificar el tipo de elementos que se almacenarán al instanciar la lista. Esto permite usar la misma clase List en diferentes escenarios sin crear una clase contenedora separada para cada tipo de datos. Este enfoque aumenta la flexibilidad y la reutilización del código.
pila genérica
¿Qué es una pila genérica?
Una pila genérica es una estructura de datos implementada utilizando el concepto de genéricos, que puede almacenar elementos de diferentes tipos. En una pila genérica, puede especificar el parámetro de tipo para definir el tipo de elemento que se almacenará y realizar operaciones comunes en la pila, como empujar y extraer.
Las definiciones de pila genéricas normalmente usan clases o interfaces y usan corchetes angulares (<>) para especificar parámetros de tipo.
Beneficios de las pilas genéricas
1. Evite los errores de conversión de tipos: al usar genéricos, puede evitar el problema de las conversiones de tipos frecuentes cuando usa la pila. La pila genérica realizará una verificación de tipos en el momento de la compilación para garantizar que solo se puedan almacenar elementos del tipo especificado, mejorando así la seguridad de tipos del código.
2. Mejorar la legibilidad y mantenibilidad del código: la pila genérica puede almacenar y operar diferentes tipos de datos, haciendo que el código sea más general y legible. No es necesario crear diferentes clases de pila para cada tipo de datos, lo que reduce la escritura de código redundante y mejora la capacidad de mantenimiento del código.
3. Reutilización de código: al definir una pila genérica, puede usar la misma pila para implementar la lógica en diferentes escenarios sin volver a implementar la pila para cada tipo. Esto reduce la duplicación de código y mejora la reutilización y escalabilidad del código.
4. Optimización del rendimiento: dado que la pila genérica determina el tipo que se almacenará en tiempo de compilación, el compilador puede optimizar el código al generar código de máquina. Esto puede conducir a un rendimiento del tiempo de ejecución más eficiente, ya que ya no se requieren conversiones y verificación de tipo de tiempo de ejecución.
5. Restricciones en los tipos de datos: mediante el uso de genéricos, se pueden restringir los tipos de datos almacenados en la pila. Esto significa que solo se pueden almacenar elementos del tipo especificado, lo que proporciona restricciones de datos más estrictas y reduce posibles errores y excepciones.
En general, las pilas genéricas proporcionan estructuras de datos más flexibles, con seguridad de tipos y reutilizables que simplifican la implementación del código y mejoran la legibilidad, el mantenimiento y el rendimiento del código.
Código
Supongamos que tenemos una matriz y necesitamos realizar continuamente la operación de inserción y extracción, por lo que la secuencia de inserción es 1,2; la extracción es 2,1;
Imagen: 
Primero, definimos una matriz y le damos un valor inicial:
public static int[] data = new int[5];
Necesitamos una variable similar a un puntero para determinar la última posición de la matriz:
public static int size = 0;
Luego escribimos en el método stack:
public void push(int i){
data[size ++] = i;
if (size == data.length){
data = Arrays.copyOf(data,data.length * 2);
}
}
Supongamos que pasamos a 1, entonces i = 1. size = 0, porque es size++, por lo que el orden es data[0] = 1, size+1 = 1. Cuando el tamaño es igual a la longitud de la matriz, si continúo empujando la pila, la matriz se saldrá de los límites y será necesario expandirla.
El siguiente es el método pop:
public int pop(){
if(size == 0){
throw new RuntimeException("栈为空")；
}
int old = data[size-1];
size = size - 1;
return old;
}
Cabe señalar que el tamaño representa la siguiente coordenada que se insertará en la pila, por lo que el tamaño no tiene elementos y el tamaño 1 representa el elemento que se insertará en la pila.
El código completo es:
public class DemoStack {
public static int[] data = new int[5];
public static int size = 0;
/**
*
* @param i
*/
public void push(int i){
data[size ++] = i;
if (size == data.length){
data = Arrays.copyOf(data,data.length * 2);
}
}
public int pop(){
if(size == 0){
throw new RuntimeException("栈为空");
}
int old = data[size-1];
size = size - 1;
return old;
}
}
La pila genérica significa que lo que quiero insertar en la pila no es solo el tipo int del código anterior, sino también otros tipos. Así que solo tenemos que cambiar int a E
public class EDemoStack<E> {
public Object[] data = new Object[5];
public int size = 0;
/**
*
* @param i
*/
public void push(E i){
data[size ++] = i;
if (size == data.length){
data = Arrays.copyOf(data,data.length * 2);
}
}
public E pop(){
if(size == 0){
throw new RuntimeException("栈为空");
}
E old = (E) data[size-1];
size = size - 1;
return old;
}
}
Con esto, nuestro código está completo. Hagamos una prueba en el código:
public static void main(String[] args) {
EDemoStack<String> stack = new EDemoStack<>();
stack.push("123");
stack.push("喜羊羊");
stack.push("aaa");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
Resultado de salida:
