Contenido del curso
Interfaces y Clases Principales de Colecciones en Java
Otras interfaces que son muy importantes en Java son los llamados Collections
Los Collections nos van a servir para trabajar con colecciones de datos, específicamente y solamente con objetos, para esto recuerda que tenemos disponibles nuestras clases Wrapper que nos ayudan a convertir datos primitivos a objetos.
Los collections se diferencian de los arrays en que su tamaño no es fijo y por el contrario es dinámico.
A continuación te muestro un diagrama de su composición:
Como podemos observar el elemento más alto es la interfaz Collection, para lo cual, partiendo de su naturalidad de interface, entendemos que tiene una serie de métodos “básicos” dónde su comportamiento será definido a medida que se vaya implementando en más elementos. De ella se desprenden principalmente las interfaces Set y List.
La interface Set tendrá las siguientes características:
Almacena objetos únicos, no repetidos. La mayoría de las veces los objetos se almacenarán en desorden. No tenemos índice.
La interface List tiene éstas características:
Puede almacenar objetos repetidos. Los objetos se almacenan en orden secuencial. Tenemos acceso al índice.
Si seguimos analizando las familias tenemos que de Set se desprenden:
Clase HashSet Interfaz SortedSet y de ella la clase TreeSet.
HashSet los elementos se guardan en desorden y gracias al mecanismo llamado hashing (obtiene un identificador del objeto) permite almacenar objetos únicos.
TreeSet almacena objetos únicos, y gracias a su estructura de árbol el *acceso es sumamente rápido.
Ahora si analizamos la familia List, de ella se desprenden:
Clase ArrayList puede tener duplicados, no está sincronizada por lo tanto es más rápida Clase Vector es sincronizada, los datos están más seguros pero es más lento. Clase LinkedList, puede contener elementos duplicados, no está sincronizada (es más rápida) al ser una estructura de datos doblemente ligada podemos añadir datos por encima de la pila o por debajo.
Sigamos con Map
Lo primero que debes saber es que tiene tres implementaciones:
HashTable LinkedHashMap HashMap SortedMap ➡️ TreeMap
La interfaz Map no hereda de la interfaz Collection porque representa una estructura de datos de Mapeo y no de colección simple de objetos. Esta estructura es más compleja, pues cada elemento deberá venir en pareja con otro dato que funcionará como la llave del elemento.
Map
Donde K es el key o clave Donde V es el value o valor
Podemos declarar un map de la siguiente forma:
Map<Integer, String> map = new HashMap<Integer, String>(); Map<Integer, String> treeMap = new TreeMap<Integer, String>(); Map<Integer, String> linkedHashMap = new LinkedHashMap<Integer, String>();
Como observas solo se puede construir el objeto con tres elementos que implementan de ella: HashMap, TreeMap y LinkedHashMap dejando fuera ++HashTable++ y ++SortedMap++. ++SortedMap++ estará fuera pues es una interfaz y ++HashTable++ ha quedado deprecada pues tiene métodos redundantes en otras clases. Mira la funcionalidad de cada uno.
Como te conté hace un momento Map tiene implementaciones:
HashMap: Los elementos no se ordenan. No aceptan claves duplicadas ni valores nulos. LinkedHashMap: Ordena los elementos conforme se van insertando; provocando que las búsquedas sean más lentas que las demás clases. 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.
Para iterar alguno de estos será necesario utilizar la interface Iterator y para recorrerlo lo haremos un bucle while así como se muestra:
Para HashMap
// 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)); }
Para LinkedHashMap
// Imprimimos el Map con un Iterador Iterator it = linkedHashMap.keySet().iterator(); while(it.hasNext()){ Integer key = it.next(); System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key)); }
Para TreeMap
// Imprimimos el Map con un Iterador Iterator it = treeMap.keySet().iterator(); while(it.hasNext()){ Integer key = it.next(); System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key)); }
Ahora lee esta lectura y en la sección de tutoriales cuéntanos en tus palabras cómo funciona Deque.
Andres López
Estudiante
Vanesa Percy
Estudiante
David Galicia Gomez
Estudiante
Joel Pimentel Salvatierra
Estudiante
Agustín Rafael Tortello Ditta
Estudiante
Usuario anónimo
User
Brandon Pinzón Pérez
Estudiante
Enrique Ruvalcaba
Estudiante
Natalia Gutierrez
Estudiante
Juan Diego Suárez Londoño
Estudiante
Esteban Cerda Román
Estudiante
Antony Suica Cuartas
Estudiante
Elvis Rafael Perez Gutierrez
Estudiante
LUIS ALEJANDRO BERNAL ROMERO
Estudiante
Jesús Enrique García
Estudiante
Alejandro Ching
EstudianteAndres López
Estudiante
Ricardo Rito Anguiano
Estudiante
Rodrigo Emmanuel Chi Ozalde
Estudiante
Johann Eduardo Rangel
Estudiante
Katherine Benjumea
Estudiante
Diego Joel Requejo Torero
Estudiante
Jaime Ortiz
Estudiante
Cristian Felipe Patiño Cáceres
Estudiante
BRYAN ARIEL MENDOZA MENOSCAL
Estudiante
Robert Báez
Estudiante
Denis Morales
Estudiante
Carlos Chirinos
Estudiante
Silvana Rolón
Estudiante
Daniel Jaramillo
Estudiante
Andrés Antonio Azuara Portillo
EstudianteNo se ustedes, pero para mi este tema ameritaba Clases en video.
Si ameritaba una explicación en vídeo. Gracias al compañero Augusto1 por esa lista de reproducción.
Saludos.
Tienes razon, creo que deberiamos haberlo visto en accion. Bueno, queda buscar algun video aparte en YT
El objetivo de las estructuras de datos es el de facilitar la organización de los datos para una manipulación eficiente de los mismos con el mínimo de recursos (tiempo de proceso y espacio de memoria) . Tenemos las siguientes estructuras: Listas, pilas, colas, arboles, etc., la cual deberemos de seleccionar de acuerdo al tipo de problema que queremos resolver.
Deque es una cola de doble extremo. Una cola de doble extremo es una colección lineal de elementos que admite la inserción y eliminación de elementos en ambos puntos finales. La interfaz Deque es un tipo de datos abstractos más rico que una pila (Stack) y una cola (Queue) porque implementa ambas (pilas y colas) al mismo tiempo. La interfaz Deque define métodos para acceder a los elementos en ambos extremos de la instancia de Deque. Se proporcionan métodos para insertar, eliminar y examinar los elementos. Clases predefinidas como ArrayDeque y LinkedList implementan la interfaz Deque
Esta es parte de la traducción del sitio que proponen al final de esta clase, buena esa!
Un deque nos permite tener el comportamiento LIFO y FIFO en una misma estructura. Este nos permite:
Añadir elementos al inicio o al final
Eliminar elementos del inicio o final
Y consultar elementos al inicio o al final. (método retrieve)
La inserción, eliminación y consulta, tienen respectivamente 2 métodos para el inicio y 2 para la salida, para un total de 12 métodos principalmente.
Collections
Collection en Java es un framewok que provee una arquitectura para almacenar y manipular un grupo de objetos. Los Java Collections pueden realizar todas las operaciones que se realizan en los datos, como búsquedas, ordenación, inserción, manipulación y eliminación.
Java Collection significa una sola unidad de objetos. Provee de:
Interfaces
Classes
Siven para trabajar con colecciones de datos, especificamente y solamente con objetos, para ello existen las clases Wrapper que permiten convertir datos primitivos a objetos.
Los collections se diferencian de los arrays en que su tamaño no es fijo y por el contrario es dinámico.
Jerarquía del Collection Framework
List
Es una interfaz para un tipo de estructura de datos como lista, en la cual se puede guardar la colección ordenada de objetos. Puede tener valores duplicados.
Implementada por las clases:
ArrayList
Utiliza un arreglo dinámico para guardar los elementos duplicados de diferentes tipos de datos. Mantiene el orden de inserción y es no-sincronizado. Los elementos guardados en un ArrayList pueden ser accedidos de forma aleatoria.
LinkedList
Internamente utiliza una lista doblemente ligada para guardar los elementos. Puede tener valores duplicados. Mantiene el orden de inserción y es no-sincronizado. La manipulación es rápida debido a que el cambio no es requerido.
Vector
Utiliza un array dinámico para guardar los elementos. Es similar a ArrayList, sin embargo el Vector es sincronizado y contiene muchos métodos que no son parte de Collection framework.
Stack
Es la subclase de Vector. Sus elementos al ser insertados usan la estructura Last-In-First-Out, es decir Pila. El Stack contiene todos los métodos de Vector y sus propios métodos como push(), y peek().
Queue
Es una interfaz que mantiene el orden de First-In-First-Out. Puede ser definida como una lista ordenada que es usada para mantener los elementos que están por ser procesados. Las clases o interfaces que implementan esta interfaz son:
PriorityQueue
Mantiene los objetos a punto de ser procesados por sus prioridades. No permite guardar valores nulos. Cada que se saca un elemento será el menor. También los elementos pueden ser ordenados usando un Comparator.
Deque (interface)
Es una interfaz que extiende la interfaz Queue. Deque permite añadir y eliminar elementos por ambos lados de la lista. Deque significa double-ended queue lo cual permite realizar operaciones en ambos lados.
ArrayDeque
Es una clase que implementa la interfaz Deque. A diferencia de Queue esta clase permite agregar/eliminar elementos por ambos lados.
Esta clase es más rápida que ArrayList y Stack y no tiene restricciones de capacidad.
Set
Es una interfaz que representa el conjunto de elementos no ordenados y no duplicados. Unicamente se puede guardar un sólo valor null. Es implementada por:
HashSet
Representa la colección que usa una Hash Table para almacenar. El Hashing es usado para guardar los elementos en el HashSet. Contiene sólo elementos únicos, no permite duplicados.
LinkedHashSet
Representa la implementación de lista ligada de Set. Extiende la clase HashSet. Sólo contiene elementos únicos. Mantiene el orden de inserción y permite elementos null.
SortedSet (interface)
Es una interfaz como Set pero que automáticamente ordena los elementos en orden ascendente. También cuenta con métodos adicionales que inhiben el ordenamiento natural de los elementos.
TreeSet
Utiliza un tree para el almacenamiento, sólo contiene elementos únicos. El tiempo de acceso y recuperación de un elemento es rápido. Los elementos son guardados en orden ascendente.
Map
Contiene elementos clave-valor. Un Map no permite claves repetidas pero valores duplicados sí. Un Map es útil si tienes que buscar, actualizar o eliminar elementos haciendo uso de una clave.
Un Map no puede ser recorrido, para hacerlo es necesario convertirlo a un Set, usando keySet() o entrySet().
Interfaces
Clases
HashMap
No mantiene el orden de inserción. Permite clave y valores null.
LinkedHashMap
Mantiene el orden de inserción. Permite clave y valores null.
TreeMap
No permite clave o valores null. Ordena los elementos de forma ascendente.
Fuente
Gracias por traer esta informacion.
Esto me recordó a mi clase de estructura de datos en la U... y tuve flashbacks vietnamitas :,v
Justo estoy llevando esa materia. La clase me queda genial.
De mis favoritas es MAP, tiene una gran utilidad para guardar los datos con indices. Algo asi como una tabla en memoria.
Este tema deberia ser mas explicado a fondo
Estoy de acuerdo, una de las cosas que más se usan a nivel profesional son las colecciones y hay que saberlas manejar al detalle.
Es bastante amplia la explicación, me metí en la documentación de Oracle y hay mucha información al respecto, pero podría decirse que una interfaz collection set o list se maneja como una lista de tuplas, ya que pueden ser o no organizadas, pero siempre linealmente, y una interfaz map se maneja como un diccionario ya que esta estructurada bajo el mismo formato key:value.
Muy buena forma de verlo, me ayudo a entender mejor.
Un deque (usualmente pronunciado como deck) es una interfaz en Java que permite manejar datos en una estructura de datos doblemente ligada (también conocida como una cola de doble terminación). Esto último es una colección lineal de elementos en la que se pueden insertar y eliminar elementos al principio y al final de la colección. La interfaz deque proporciona métodos para acceder a ambos lados de la instancia de deque y realizar operaciones como insertar, borrar y recuperar elementos.
Python soluciona todo esto de manera super facil usando solo {} () [], de igual manera, es bueno que en java a pesar de ser mas complejo tambien tenga esas posibilidades :D
No es muy claro como funcionan las colleciones espero se explique más adelante como ya que con ejemplos prácticos se entendió muy bien polimorfismos, herencia e interfases
Hola, ya termine este curso y no hay mas información, lo mejor es que busques por tu cuenta abajo compartieron algunos links e información que te ayudara, este es un tema complejo y tienes que complementarlo con mas información, te recomiendo este video Aqui
Para este tema si es importante la clase, sin embargo busque esto. espero que les sirva: https://www.youtube.com/watch?v=bTu-fz1JmWQ
Deque es una interface que ayuda a manejar pilas o colas con su naturaleza FIFO (first in, first output) o LIFO (last in, first out)
Tal vez, podría darse uso para almacenar mensajes, peticiones, o sistema de colas (como en algunas entidades bancarias).
No me quedó claro estos nuevos conceptos. No encuentro el uso práctico. HashSet es lo mismo que conjuntos, Map es igual a diccionarios, ArrayList es igual a Listas dinámicas; pero sus compañeros como TreeMap, TreeSet,LinkendList no entiendo el concepto y no encuentro el uso práctico.
Tree (arboles) es una estructura de datos para almacenar información que puede ser buscada de una manera mucho mas rapida que otras estructuras como listas
ehh regresado y si me alargado de mas en esta clase les recomiendo cojer bases solidas aqui vengo del futuro y necesitaran saber cual elegir a futuro
Para este momento hemos aprendido mucho y es momento de poner ver nuevos conceptos es muy posible que ya algunos esten usando lo que me hemos mostrado a continuacion o ya tuviero su primer acercamiento con aquello sin mas empecemos. Que son las collections veamolo como mas bodegas para poder almacenar pero ya no datos. Ni cadenas string ni ni tipo de dato primitivo ahora almacenaremos Objetos y esto es gracias a nuestras clases warpper que son aquellas que nos permiten convertir y usar datos primitivos a objetos recalco las clases que veremos a continuacion cada una tiene caracteristicas que le hacen muy especial y diferente veamos.
Como podemos visualizar en la imagen tenemos la superclase Collection de esta se despliega las clases hijas set y list como ya lo mencione antes cada una con sus caracteristicas pero comencemos con una.
Set esta como caracteristicas principales no nos deja tener datos duplicados solo unicos, los objetos se almacenaran en desorden no contamos con indices esta cuenta con metodos para busca, eliminacion y agregar pero estos depedaran de cual de sus variantes usemos. Pero en general es muy eficiente para la eliminacion de datos, adicion y la busqueda recalco depende sus variantes pero cuales son estas veamos:
àHashset esta tiene como caracteristicas no podemos tener datos duplicados no tenemos un orden especificio pero esta a diferencia de su padre nos ayudara a encontrar datos o lo que tengamos almacenado de manera eficiente y rapida gracias a que esta asigna un dato numerico a cada objeto para poder buscarlo de forma rapida.
àSortedSet este si ordena nuestro objetos o datos , no podemos tener datos repetidos ya que estos son eliminados al momento y en lo que respeta a datos y eficiencia rapida para busca y eliminacion es muy eficiente debido a que se usa tiempo algortimico pero aquí surge una incognita ¿Que es esto? El concepto general nos dice que este trabaja mucho mejor cuando la entrada es de muchos datos, ya que este aumenta de formas lenta a medida que mas datos se procesan y esto dado como resultado mas eficiencias, esto es debido a que la busqueda binaria separa nuestra lista, objetos o datos en dos para hacer una busqueda muchas rapida esto se hace simplemente con divisiones y mas eficiente cuando esta supera los 10 datos.
àTreeSet esta nos ayuda ordenando nuestro datos de forma natural o de forma personalizada, no permite elementos duplicados si usted intenta agregar datos de este tipos simplemente seran eliminados, es basado en arboles binarios que quiere decir esto que este tipo de estructura de datos es muy eficiente en busca, eliminacion y insercion
Por otro lado tenemos las list esta es un amor para mi es eficiente en cierta cosas como es ordenado y flexible con los datos cada elemento cuenta con un indice con el cual podemos acceder a este y estas nos permiten tener elementos duplicados sin tener algun inconveniente este nos ofrece variedad de metodos que veremos poco a poco sin mas que decir porfundicemos.
àArrayList estas nos permite tener elemento duplicados, para busquedas de elementos no es muye eficiente ya que esta es dinamica crece a medida que se le agregan sus elementos cada uno esta ordenado y cuenta con un indice, eliminar datos facil independientemente del metodo personalidada aunque recalco si eliminamos el elemento final es muy rapido pero elemento del medio puede ser muy costoso.
Esta no es sincronizada algo que se me escapaba era el concepto de este que es esto. Cuando una lista cuenta con este topico se nos da conocer que es una lista segura aunque puede llegar a ser un poco lentos
/* *futuro lector puedes completemetar este texto leyendo logica de programacion y haciendo tu propio proyecto */
àVector esta es una clase sincronizada debido a esta cualidad aquella es un poco lenta pero se mantienen seguro los datos que estan almacenados esto esta hecha para ser utilizada en entornos multiHilos pero aquí nace una duda que SON LOS HILOS? Estos son los encargados de las que tareas se cumplan pero como es posible esto pensemos en esto como un taxi o un delivery que se le carga ir del punto A al punto B es asi como los hilos nos ayudan a ejecutar datos pero entonces que son los MULTiHILOS? Estos son aquellos que se encargan de ejecutar varias tareas ojo no todas al mismo tiempo esto depende de tu procesador veamos un poco mas profundo para que logres entender esto. Tenemos dos tipos principales de hilos de usuario y de sistema el primero es creado por nosotros y gestionado por nuestra app o software. El segundo es gestionado y planificado por nuestro sistema este es muy pesado pero se beneficia de la optimizacion del sistema por otro lado el del usuario esto son ligeros, rapido de crear pero no se benefician del sistema que beneficios nos pueden dar los hilos es una excelente pregunta lector entre los principales ya antes mecionados tenemos fluidez, rapidez, eficiencia, mejor uso de recursos, modularidad y respuesta respuesta pero veamos conceptos claves para poder entender mas.
*- Concurencia : este nos dice que el sistema tiene la capacidad de gestionar multiples tareas a la vez pero se aclara que no se ejecutan al mismo tiempo pero puede progresar juntas se que esto parece una contradicion dicha en primera plana como ya antes se les menciona depende tambien de su multiprocesador.
*-Paralelismo : En este caso se nos dice que tiene la capacidad de ejecutar tareas multiples tareas al mimso tiempo ojo requiere multiprocesador ya antes mecionado.
*-DeadLock: situacion donde uno o mas hilos estan esperando que otros terminen por tal no avanzan.
àLinkedList esta es una clase que puede contener elementos duplicados ojo esta no esta sincronizada por es mas eficiente mas rapido se nos dice que esta clase es de doble fila que quiere decir esto nos dice que podremos navegar tanto para adelante y para atrás un pequeña analogia para que logres comprender digamos que quieres buscar la siguiente palabra “Fuck”. Y separamos la mitad y comenzamos a buscar en caso que no este vamos hasta adelante sino hasta atrás tenemos libertad de movimiento para poder buscar nuestros datos. Algo que acortar sobre esta lista cada numero sabe sin es el siguiente debido que estan en comunicación constante esto la convierten en una lista eficiente para eliminacion y bsuqueda de datos.
Me parecio interesante la informacion que compartes y como le has explicado que quiero hacer un pequño aporte a nivel de ejemplo, que seria basados en Set, Hashset, SortedSet, TreeSet.
Clase Users
Implementa Compareble para el uso de SortedSet
y los metodo equals y hasCcode para manejar los duplicado en las listas
import java.util.Objects; public class Users implements Comparable<Users>{ private Integer id; private String name; private String lastName; private String email; private char sex; private int phone; public Users() { } public Users(Integer id, String name, String lastName, String email, char sex, int phone) { this.id = id; this.name = name; this.lastName = lastName; this.email = email; this.sex = sex; this.phone = phone; } public Users(Integer id, String name, String lastName, String email) { this.id = id; this.name = name; this.lastName = lastName; this.email = email; } public int getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public int getPhone() { return phone; } public void setPhone(int phone) { this.phone = phone; } @Override public String toString() { return "Users{" + "id=" + id + ", name=" + name + ", lastName=" + lastName + ", email=" + email + ", sex=" + sex + ", phone=" + phone + '}'; } @Override public int hashCode() { int hash = 5; hash = 97 * hash + Objects.hashCode(this.id); hash = 97 * hash + Objects.hashCode(this.name); hash = 97 * hash + Objects.hashCode(this.lastName); hash = 97 * hash + Objects.hashCode(this.email); return hash; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final Users other = (Users) obj; if (!Objects.equals(this.name, other.name)) { return false; } if (!Objects.equals(this.lastName, other.lastName)) { return false; } if (!Objects.equals(this.email, other.email)) { return false; } return Objects.equals(this.id, other.id); } @Override public int compareTo(Users user) { return Integer.compare(this.id, user.id ); } } ````Clase CollectionsExample` Clase principal para ejecucion con metodos estaticos. ```java import collectionsexample.model.Users; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; public class CollectionsExample { public static void main(String[] args) { System.out.println("Collection with java\n"); manageSetInterface(); sortedListWithOutDuplicate(); } //Trabajando con la interface Set para manejo de duplicados // con los metodos equal y hashcode public static void manageSetInterface() { List<Users> lstUsers = new ArrayList<>(); lstUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com")); lstUsers.add(new Users(2, "Sergio", "Alcantara", "SAlcantara@mlb.com")); lstUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com")); lstUsers.add(new Users(4, "Harold", "Ramirez", "HRamirez@mlb.com")); lstUsers.add(new Users(5, "Junior", "Severino", "JSeverino@mlb.com")); lstUsers.forEach(System.out::println); Set<Users> setUsers = new HashSet<>(lstUsers); List<Users> lstSinDuplicado = new ArrayList<>(setUsers); System.out.println("\nSin Duplicados"); lstSinDuplicado.forEach(System.out::println); } public static void sortedListWithOutDuplicate() { SortedSet<Users> sortedUsers = new TreeSet<Users>(); sortedUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com")); sortedUsers.add(new Users(2, "Sergio", "Alcantara", "SAlcantara@mlb.com")); sortedUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com")); sortedUsers.add(new Users(4, "Harold", "Ramirez", "HRamirez@mlb.com")); sortedUsers.add(new Users(5, "Junior", "Severino", "JSeverino@mlb.com")); System.err.println("Lista Ordenada Sin duplicados."); sortedUsers.forEach(System.out::println); for (Users u : sortedUsers) { System.out.println(u.getId() + " :: " + u.getName() + " -> " + u.getEmail()); } } }
Deck o Deque, es una lista tipo cola de doble extremo, es decir permite agregar o retirar objetos por ambos lados: inicio de la cola o final de la cola.
(permite ingresar y retirar elementos) inicio cola - [ ] - [ ] - [ ] - fin cola (permite ingresar y retirar elementos)
La interfaz de deck permite agregar elementos , eliminar elementos y recuperar elementos (este ultimo solo recupera el valor mas no elimina el elemento de la lista). para cada uno la interfaz es especifica por que en los metodos se indica si quieres realizar la operacion por el inicio o el final de la lista.
Realmente decepcionante qque un teme tan complejo y tan relevante como Collections, lo manejen de esta manera. Esto debio ser visto a traves de videos con la instructora!
Me confunde un poco leer tantos Map, LinkedHashMap y demás, pero creo que voy comprendiendo poco a poco
Según entendí es una forma de manipular los datos mediante dos colas, donde se insertan los nodos en cualquiera de los dos extremos lo caul la hace mas dinamica
Si los LinkedHashMap son ordenados al ser insertados, dice que la busqueda sería mas lenta, pero no sería mas rapida la busqueda pero mas lenta la inserción?