ESTRUCTURAS DE DATOS

Actividad 4

Resumen
A partir de la información suministrada en la guía y con investigación complementaria se da
respuesta al significado de las siguientes estructuras de datos: Java.util.Map,
Java.util.HashMap. ¿Qué son los generics en Java?

JUAN PABLO SUAREZ RAMIREZ

[email protected]
 INTRODUCCIÓN

En esta actividad, exploraremos estructuras de datos esenciales en Java y su

aplicación en el desarrollo de software. Analizaremos los conceptos clave de
Java.util.Map y Java.util.HashMap, y discutiremos el uso de generics en Java.
Finalmente, elaboraremos un texto detallado sobre las estructuras de datos más
comunes: listas, pilas y colas, resaltando sus definiciones, métodos principales y
diferencias.
1. estructuras de datos

Java.util.Map

¿Para qué sirve?

Java.util.Map es una interfaz en Java que representa una colección de pares clave-
valor. Es útil para almacenar datos donde cada clave única está asociada a un valor.
Los mapas son ideales para situaciones en las que necesitamos realizar búsquedas
rápidas basadas en claves.

Permite aplicar una función dada a cada elemento de una colección y devolver una
nueva colección con los resultados. Esta función es muy útil para realizar
operaciones como la transformación o filtrado de datos en una colección.

Por ejemplo, supongamos que queremos convertir una lista de cadenas en

mayúsculas a minúsculas. Podríamos hacerlo de la siguiente manera con map:

List<String> words = Arrays.asList("the", "quick", "brown", "fox");

List<String> lowercaseWords = words.stream()

.map(word -> word.toLowerCase())
.collect(Collectors.toList());

En este ejemplo, primero obtenemos un Stream de la lista words, luego usamos la

función map para aplicar el método toLowerCase a cada elemento del Stream, y
finalmente usamos el método collect para recolectar los resultados en una nueva
lista.

La función map también se puede utilizar con expresiones lambda, lo que permite
aún más concisión en el código:
List<String> words = Arrays.asList("the", "quick", "brown", "fox");

List<String> lowercaseWords = words.stream()

.map(String::toLowerCase)
.collect(Collectors.toList());

Métodos principales:

• put(K key, V value): Inserta una asociación clave-valor en el mapa.

• get(Object key): Devuelve el valor asociado con la clave especificada.

• remove(Object key): Elimina la entrada para la clave especificada.

• containsKey(Object key): Verifica si el mapa contiene la clave especificada.

• containsValue(Object value): Verifica si el mapa contiene el valor

especificado.

• size(): Devuelve el número de entradas en el mapa.

• isEmpty(): Verifica si el mapa está vacío.

• clear(): Elimina todas las entradas del mapa.

Java.util.HashMap

¿Para qué sirve?

Java.util.HashMap es una implementación concreta de la interfaz Map que utiliza una

tabla hash para almacenar los pares clave-valor. HashMap es eficiente para
operaciones de inserción, eliminación y búsqueda de elementos.

A diferencia de las colecciones, que guardan los valores de forma ordenada y cuyo
índice es simple un número entero (int), los HashMap guardan sus valores con un
índice definido por el programador cómo por ejemplo un String.

La forma más fácil de crear un HashMap es usando su constructor con los genéricos
definidos:

HashMap<String, Empleado> empleadosPorNombre = new

HashMap<>();
Aunque también podremos usar la interfaz Map para inicializar nuestro objecto:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();

En la mayoría de los casos, deberíamos usar claves inmutables. O al menos,

debemos ser conscientes de las consecuencias de utilizar claves mutables.

Veamos qué sucede cuando nuestra clave cambia después de que la usamos para
almacenar un valor en un mapa.

Para este ejemplo, crearemos IndiceHash:

public class IndiceHash {

private Integer indice;

@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
 if (o == null || getClass() != o.getClass()) {
return false;
}
IndiceHash that = (IndiceHash) o;
return Objects.equals(indice, that.indice);
}

@Override
public int hashCode() {
return Objects.hash(indice);
}
}

Y esta es la lógica:

IndiceHash clave = new IndiceHash(1);

Map<IndiceHash, String> elementos = new IndiceHash<>();

elementos.put(key, "success");

elementos.setIndice(2);

System.out.println(elementos.get(clave));

Como podemos ver, ya no podemos obtener el valor correspondiente una vez que la
clave ha cambiado, en su lugar, se devuelve null. Esto se debe a que HashMap está
buscando en con el indice equivocado.

El caso de prueba anterior puede ser sorprendente si no tenemos una buena

comprensión de cómo funciona internamente HashMap.

Métodos principales:

• put(K key, V value): Inserta una clave y un valor en el mapa.

 • get(Object key): Recupera el valor asociado a una clave.

• remove(Object key): Elimina una entrada con la clave especificada.

• containsKey(Object key): Comprueba si existe una clave en el mapa.

• containsValue(Object value): Comprueba si existe un valor en el mapa.

• keySet(): Devuelve un conjunto de todas las claves en el mapa.

• values(): Devuelve una colección de todos los valores en el mapa.

2. ¿Qué son los generics en Java?

Los generics en Java son una característica que permite definir clases, interfaces y
métodos con parámetros de tipo. Esto proporciona una mayor seguridad de tipo en
tiempo de compilación, evitando errores de tipo y reduciendo la necesidad de
conversiones explícitas. Los generics hacen que el código sea más reutilizable y
legible.

Ejemplo:

List<String> list = new ArrayList<>();

list.add("Hola");

String s = list.get(0); // No necesita casting

3. Texto sobre estructuras de datos: listas, pilas y colas

Listas:

Una lista es una estructura de datos lineal que almacena elementos en un orden
secuencial. Cada elemento tiene un índice asociado, lo que permite el acceso rápido
a los elementos.

Métodos principales:

• add(E e): Agrega un elemento al final de la lista.

• get(int index): Recupera el elemento en una posición específica.
• remove(int index): Elimina el elemento en la posición especificada.
• size(): Devuelve el número de elementos en la lista.

Diferencias frente a otras estructuras:

• A diferencia de las pilas y colas, las listas permiten el acceso aleatorio a los
elementos.
• Las listas pueden contener duplicados y permiten elementos null.

Pilas:

Una pila es una estructura de datos LIFO (Last In, First Out), donde el último elemento
en entrar es el primero en salir. Es útil para tareas como la evaluación de expresiones,
retroceso en navegadores web, y llamadas recursivas.

Métodos principales:

• push(E e): Agrega un elemento en la parte superior de la pila.

• pop(): Elimina y devuelve el elemento en la parte superior de la pila.
• peek(): Devuelve el elemento en la parte superior sin eliminarlo.
 • isEmpty(): Verifica si la pila está vacía.

Diferencias frente a otras estructuras:

• Las pilas no permiten acceso aleatorio; solo se puede acceder al último

elemento insertado.
• No suelen permitir la iteración de los elementos sin eliminarlos.

Colas:

Una cola es una estructura de datos FIFO (First In, First Out), donde el primer
elemento en entrar es el primero en salir. Las colas son útiles para administrar tareas
en orden de llegada, como en sistemas de impresión o procesamiento de datos.

Métodos principales:

• add(E e): Agrega un elemento al final de la cola.

• remove(): Elimina y devuelve el primer elemento de la cola.
• peek(): Devuelve el primer elemento sin eliminarlo.
• isEmpty(): Verifica si la cola está vacía.

Diferencias frente a otras estructuras:

• A diferencia de las pilas, las colas mantienen el orden de inserción.

• Las colas no permiten el acceso aleatorio, sólo se puede acceder al primer
elemento.

Estas estructuras de datos son fundamentales en la programación y se utilizan para

resolver problemas específicos de manera eficiente. La elección de una estructura
adecuada depende de los requisitos de la aplicación y el tipo de operaciones que se
deben realizar con los datos.
 REFERENCIAS

(Estructura de Datos - Wikipedia, La Enciclopedia Libre, n.d.

Explicando La Función Map de Las Colecciones Java, n.d.

HASHMAP En JAVA, n.d.; HashMap (Java Platform SE 8 ), n.d.

Java Programs - Javatpoint, n.d.

Map (Java Platform SE 8 ), n.d.

Peláez & Peláez, 2018)