1. Java.util.

Map, para que sirven y cuáles son sus métodos principales

El tipo de dato Map, incluido en el paquete java. util, permite modelar el

concepto de aplicación: una relación entre los elementos de dos conjuntos de
modo que a cada elemento del conjunto inicial le corresponde uno y solo un
elemento del conjunto final. Los elementos del conjunto inicial se denominan
claves (keys) y los del conjunto final valores (values).

Esta estructura de datos también es conocida en otros lenguajes de

programación como "Diccionarios", aunque en cada lenguaje esta estructura de
datos tiene sus matices. Al igual que dijimos en la entrada de " ArrayList en Java,
con ejemplos" los Maps en java tienen implimentada por debajo toda la teoría de
las estructuras de datos de los Arboles (AVL, B, B+, B*) por tanto permiten
añadir, eliminar y modificar elementos de forma trasparente para el
programador.

Los principales métodos para trabajar con los Map son los siguientes:

// Declaración de un Map (un HashMap) con clave "Integer" y Valor "String". Las claves pueden ser
de cualquier tipo de objetos, aunque los más utilizados como clave son los objetos predefinidos de
Java como String, Integer, ¡Double ... !!!!CUIDADO los Map no permiten datos atómicos
Map<Integer, String> nombreMap = new HashMap<Integer, String> ();
nombreMap.size(); // Devuelve el número de elementos del Map
nombreMap.isEmpty(); // Devuelve true si no hay elementos en el Map y false si los hay
nombreMap.put (K clave, V valor); // Añade un elemento al Map
nombreMap.get (K clave); // Devuelve el valor de la clave que se le pasa como parámetro o 'null' si
la clave no existe
nombreMap.clear(); // Borra todos los componentes del Map
nombreMap.remove(K clave); // Borra el par clave/valor de la clave que se le pasa como parámetro
nombreMap.containsKey(K clave); // Devuelve true si en el map hay una clave que coincide con K
nombreMap.containsValue(V valor); // Devuelve true si en el map hay un Valor que coincide con V
nombreMap.values(); // Devuelve una "Collection" con los valores del Map

Otro elemento importante a la hora de trabajar con los Maps (aunque no

lo es tanto como a la hora de trabajar con los ArrayList) son los
"Iteradores" (Iterator). Los Iteradores sirven para recorrer los Map y poder
trabajar con ellos. Los Iteradores solo tienen tres métodos que son el  “hasNext
()” para comprobar que siguen quedando elementos en el iterador, el “next
()” para que nos dé el siguiente elemento del iterador; y el “remove ()” que sirve
para eliminar el elemento del Iterador. En realidad, se puede prescindir de los
iteradores para trabajar con los Map ya que la gran ventaja de los Map frente a
los ArrayList, es que estos tienen una clave asociada al objeto y se les puede
buscar por la clave, aunque nunca está de más saber utilizar los iteradores para
manejar los Map.

https://jarroba.com/map-en-java-con-ejemplos/#:~:text=La%20Interface%20Map
%20(java.&text=Map)%20en%20Java%2C%20nos%20permite,clave
%20solamente%20tenemos%20un%20valor.

Un dato muy importante es referente a "HashMap", "TreeMap" y

"LinkedHashMap". La diferencia principal de estas 3 clases es la forma o el
orden en las que guardan los valores en el Map.

 HashMap: Los elementos que inserta en el map no tendrán un orden

específico. No aceptan claves duplicadas ni valores nulos.
 TreeMap: El Mapa lo ordena de forma "natural". Por ejemplo, si la clave
son valores enteros (como luego veremos), los ordena de menos a
mayor.
 LinkedHashMap: Inserta en el Map los elementos en el orden en el que
se van insertando; es decir, que no tiene una ordenación de los
elementos como tal, por lo que esta clase realiza las búsquedas de los
elementos de forma más lenta que las demás clases.

¿Qué es Hashmap en Java? Un HashMap básicamente designa claves

únicaspara los valores correspondientes que se pueden recuperar en cualquier
punto dado.

Uso de HashMaps en programas Java:

Las siguientes son las dos formas de declarar un mapa hash:

1 HashMap<String, Object>map=new HashMap<String, Object> ();

2 HashMap x= new HashMap ();

Métodos importantes de Hashmap

 get (Object KEY) – Esto devolverá el valor asociado con una clave
especificada en este hashmap de Java.
 put (Object KEY, String VALUE) – Este método almacena el valor
especificado y lo asocia con la clave especificada en este mapa.

Características de Java Hashmap

 a) Los valoresse pueden almacenar en un mapa formando un par clave-

valor. El valor se puede recuperar usando la clave pasándola al método
correcto.
 b) Si no existe ningún elemento en el Mapa, arrojará una
‘NoSuchElementException’.
 c) HashMap almacena solo referencias de objetos. Por eso, es imposible
utilizar tipos de datos primitivos como doublé o int. Utilice la clase
contenedora (como Integer o Double) en su lugar.
Ejemplo con Hashmap

Map<Integer, String> map = new HashMap<Integer, String> ();

map.put (1, "Casillas");
map.put (3, "Pique");
map.put (11, "Capdevila");
map.put (16, "Busquets");
map.put (18, "Pedrito");
map.put (7, "Villa");
map.put (15, "Ramos");
map.put (5, "Puyol");
map.put (14, "Xabi Alonso");
map.put (8, "Xavi Hernandez");
map.put (6, "Iniesta");

// Imprimimos el Map con un Iterador

Iterator it = map. keySet (). iterator ();
while (it. hasNext ()) {
Integer key = it.next();
 System.out.println("Clave: " + key + " -> Valor: " + map.get(key));

2. ¿Qué son los generics en java?

Hace ya más de una década que en Java 5 se introdujeron

los generics para dotar al lenguaje de una mejor comprobación de tipos en
tiempo de compilación y al mismo tiempo eliminar los cast que hasta entonces
eran necesarios al usar las colecciones. Dada la lentitud de adopción que suele
haber en la plataforma Java en los grandes entornos empresariales puede que
aún no los hayamos usado extensamente o tengamos alguna duda en su uso.
Hay unos cuantos conceptos sobre los generics que son convenientes
conocer.

 Los generics nos permiten manipular y operar con objetos sin especificar

su tipo y posibilitan reutilizar código, además de ofrecer type safety, gracias al
chequeo de tipos durante la compilación. También es posible crear métodos
genéricos, agregándoles distintos parámetros con tipos genéricos (esto es
similar a declarar un tipo genérico, pero su alcance se limita al método en el
que se declaró). Además, una clase genérica puede tener múltiples parámetros
(multiple type parameters).

3. definición de Listas, Pilas y Colas y el funcionamiento que estas cumplen

 Pilas

Una pila es una estructura que nos permite apilar elementos y recopilarlos en
el orden inverso al cual los apilamos mediante operaciones de desapilar. Esto es
lo que se conoce como estructuras LIFO (Last In First Out). De esta manera una
pila suele tener 3 operaciones básicas:

 apilar, añade un elemento a la lista.

  desapilar, retira un elemento de la lista
 ¿está vacía?, comprueba si la lista está vacía.

 Cola

Una cola es una estructura de datos, caracterizada por ser una secuencia
de elementos en la que la operación de inserción push se realiza por un extremo y
la operación de extracción pop por el otro. También se le llama
estructura FIFO (del inglés First In First Out), debido a que el primer elemento en
entrar será también el primero en salirs. En Java podemos encontrar variadas
formas de crear Colas en pocas líneas de código, un ejemplo es una de sus
Interfaces que tiene como nombre “Queue”

Métodos de Queue para manejo de Colas en Java

con la cual podemos crear Colas y que contiene los siguientes métodos para el
uso de las mismas.

Para Insertar:
– add(e)
– offer(e)

Para Extraer:
– remove()
– poll()

Para Consultar el Frente:

– element()
– peek()

Como podemos darnos cuenta, hay 2 métodos para cada operación, estos
realizan de igual forma las operaciones, pero en cierto caso 1 de ellos retornará un
valor especial “null” y el otro lanzará una excepción.
 Por ejemplo, los métodos para Extraer llamados: “remove ()” y “poll ()”.
Cuando se intenta extraer un dato de una Cola que ya está vacía el método
remove () lanzará una excepción como resultado, en cambio el método poll ()
simplemente retornará o tomará el valor null.

 listas

Una lista es una estructura dinámica de datos que contiene una colección

de elementos homogéneos (del mismo tipo) de manera que se establece entre
ellos un orden. Es decir, cada elemento, menos el primero, tiene un predecesor, y
cada elemento, menos el último, tiene un sucesor.

La estructura de datos deberá permitirnos determinar cuál es el primer

elemento y el último de la estructura, cuál es su predecesor y su sucesor (si
existen de cualquier elemento dado). Cada uno de los elementos de información
suele denominarse nodo. La lista también puede representarse de forma simbólica
escribiendo sus elementos separados por comas y encerrados entre corchetes.
Por ejemplo:

["rojo","verde","azul","amarillo"]

Las listas admiten ciertas operaciones como son insertar un nodo adicional, borrar
un nodo, etc. En función de la forma de insertar nuevos elementos y acceder a los
existente tendremos distintos tipos de listas. Veamos ahora qué operaciones básicas se
puedes realizar sobre las listas. Se tratarán aquí las operaciones que permiten insertar y
borrar elementos únicamente al principio de la misma, por lo que las operaciones de
acceso, inserción y supresión de elementos en cualquier, otro aspecto que hay que
considerar es que las posiciones de la lista no se consideran básicas, pero podrán ser
tratadas mediante recursión. Una lista enlazada requiere una estructura de datos
compleja, al contrario que las colas o las pilas, que pueden operar con elementos
simples o complejos, además una operación de recuperación en
una lista enlazada no elimina ni destruye el elemento de la lista. Entre estas
estructuras existe una gran diferencia debido a que las colas o pilas FIFO se
diferencian de las LIFO en el orden en que introducimos y extraemos los
elementos de la estructura. Mientras en las anteriores sólo disponíamos de un
extremo de la misma para la actualización de elementos, en ésta introducimos los
datos por un extremo de la lista y los extraemos por el otro. Por otra parte, las
listas se diferencian por su orden ya que en Java son variables que permiten
almacenar grandes cantidades de datos. Son similares a los Array o a las Matrices