Cualquier grupo de objetos individuales que se representan como una sola unidad se conoce como Colección de Objetos Java. En Java, un marco separado llamado el Marco de colección se ha definido en JDK 1.2, que contiene todas las clases e interfaces de la colección Java.
En Java, la interfaz Colección ( java.util.Colección ) y la interfaz de mapa ( java.util.Map ) son las dos interfaces raíz principales de las clases de colección de Java.
¿Qué debería aprender en las colecciones de Java?
- Interfaz de lista
- Clase de lista abstracta
- Clase de lista secuencial abstracta
- Lista de arreglo
- Clase vectorial
- Clase de pila
- Clase de lista vinculada
- Interfaz de cola
- Interfaz de cola de bloqueo
- Clase de cola abstracta
- Clase de cola prioritaria
- Clase PriorityBlockingQueue
- Clase ConcurrentLinkedQueue
- Clase ArrayBlockingQueue
- Clase DelayQueue
- Clase LinkedBlockingQueue
- Cola de transferencia vinculada
- y la interfaz
- Interfaz BlockingDeque
- Clase ConcurrentLinkedDeque
- Clase ArrayDeque
- Establecer interfaz
- Clase de conjunto abstracto
- Clase CopyOnWriteArraySet
- Clase EnumSet
- Clase ConcurrentHashMap
- Clase HashSet
- Clase LinkedHashSet
- Interfaz de conjunto ordenado
- Interfaz de conjunto navegable
- Conjunto de árboles
- Clase ConcurrentSkipListSet
- Interfaz de mapa
- Interfaz de mapa ordenado
- Interfaz de mapa navegable
- Interfaz de mapa concurrente
- Clase TreeMap
- Clase de mapa abstracto
- Clase ConcurrentHashMap
- Clase EnumMap
- Clase HashMap
- Clase IdentityHashMap
- Clase LinkedHashMap
- Clase HashTable
- Clase de propiedades
- Otros conceptos importantes
- Cómo convertir HashMap a ArrayList
- Seleccionar aleatoriamente elementos de una lista
- Cómo agregar todos los elementos de una colección a una ArrayList
- Conversión de mapas Java a lista
- Conversión de matriz a lista de matrices
- Conversión de ArrayList a Array
- Diferencias entre Array y ArrayList
¿Qué es un marco en Java?
Un marco es un conjunto de clases e interfaces que proporcionan una arquitectura lista para usar. Para implementar una nueva característica o clase, no es necesario definir un marco. Sin embargo, un diseño óptimo orientado a objetos siempre incluye un marco con una colección de clases tal que todas las clases realicen el mismo tipo de tarea.
Necesidad de un marco de recopilación independiente en Java
Antes de que se introdujera Collection Framework (o antes de JDK 1.2), los métodos estándar para agrupar objetos Java (o colecciones) eran matrices o Vectores , o tablas hash . Todas estas colecciones no tenían una interfaz común. Por lo tanto, aunque el objetivo principal de todas las colecciones es el mismo, la implementación de todas estas colecciones se definió de forma independiente y no tuvo correlación entre ellas. Y además, es muy difícil para los usuarios recordar todos los diferentes métodos , sintaxis y constructores presente en cada clase de colección.
Entendamos esto con un ejemplo de cómo agregar un elemento en una tabla hash y un vector.
sqrt java matemáticas
Ejemplo:
Java
// Java program to demonstrate> // why collection framework was needed> import> java.io.*;> import> java.util.*;> class> CollectionDemo {> > public> static> void> main(String[] args)> > {> > // Creating instances of the array,> > // vector and hashtable> > int> arr[] => new> int> [] {> 1> ,> 2> ,> 3> ,> 4> };> > Vector v => new> Vector();> > Hashtable h => new> Hashtable();> > // Adding the elements into the> > // vector> > v.addElement(> 1> );> > v.addElement(> 2> );> > // Adding the element into the> > // hashtable> > h.put(> 1> ,> 'geeks'> );> > h.put(> 2> ,> '4geeks'> );> > // Array instance creation requires [],> > // while Vector and hastable require ()> > // Vector element insertion requires addElement(),> > // but hashtable element insertion requires put()> > // Accessing the first element of the> > // array, vector and hashtable> > System.out.println(arr[> 0> ]);> > System.out.println(v.elementAt(> 0> ));> > System.out.println(h.get(> 1> ));> > // Array elements are accessed using [],> > // vector elements using elementAt()> > // and hashtable elements using get()> > }> }> |
>
>Producción
1 1 geeks>
Como podemos observar, ninguna de estas colecciones (Array, Vector o Hashtable) implementa una interfaz de acceso de miembros estándar, fue muy difícil para los programadores escribir algoritmos que puedan funcionar para todo tipo de colecciones. Otro inconveniente es que la mayoría de los métodos 'Vector' son finales, lo que significa que no podemos extender la clase 'Vector' para implementar un tipo similar de Colección. Por lo tanto, los desarrolladores de Java decidieron crear una interfaz común para abordar los problemas mencionados anteriormente e introdujeron el Marco de Colección en la publicación JDK 1.2, en el que tanto los vectores heredados como las Hashtables se modificaron para ajustarse al Marco de Colección.
Ventajas del marco de colección de Java
Dado que la falta de un marco de recopilación dio lugar al conjunto de desventajas anterior, las siguientes son las ventajas del marco de recopilación.
- API consistente: La API tiene un conjunto básico de interfaces como Recopilación , Colocar , Lista , o Mapa , todas las clases (ArrayList, LinkedList, Vector, etc) que implementan estas interfaces tienen alguno conjunto común de métodos.
- Reduce el esfuerzo de programación: Un programador no tiene que preocuparse por el diseño de la Colección sino que puede centrarse en su mejor uso en su programa. Por lo tanto, el concepto básico de programación orientada a objetos (es decir, abstracción) se ha implementado con éxito.
- Aumenta la velocidad y la calidad del programa: Aumenta el rendimiento al proporcionar implementaciones de alto rendimiento de estructuras de datos y algoritmos útiles porque, en este caso, el programador no necesita pensar en la mejor implementación de una estructura de datos específica. Simplemente puede utilizar la mejor implementación para aumentar drásticamente el rendimiento de su algoritmo/programa.
Jerarquía del marco de colección en Java
El paquete de utilidades (java.util) contiene todas las clases e interfaces que requiere el marco de la colección. El marco de la colección contiene una interfaz denominada interfaz iterable que proporciona el iterador para recorrer todas las colecciones. Esta interfaz se amplía mediante la interfaz de colección principal que actúa como raíz para el marco de la colección. Todas las colecciones amplían esta interfaz de colección, ampliando así las propiedades del iterador y los métodos de esta interfaz. La siguiente figura ilustra la jerarquía del marco de recopilación.
Antes de comprender los diferentes componentes del marco anterior, primero comprendamos una clase y una interfaz.
- Clase : Una clase es un modelo o prototipo definido por el usuario a partir del cual se crean objetos. Representa el conjunto de propiedades o métodos que son comunes a todos los objetos de un tipo.
- Interfaz : Al igual que una clase, una interfaz puede tener métodos y variables, pero los métodos declarados en una interfaz son abstractos por defecto (solo firma del método, nadie). Las interfaces especifican qué debe hacer una clase y no cómo. Es el modelo de la clase.
Métodos de la interfaz de colección
Esta interfaz contiene varios métodos que pueden ser utilizados directamente por todas las colecciones que implementan esta interfaz. Ellos son:
Método | Descripción |
---|---|
agregar (objeto) | Este método se utiliza para agregar un objeto a la colección. |
agregarTodo(Colección c) | Este método agrega todos los elementos de la colección dada a esta colección. |
claro() | Este método elimina todos los elementos de esta colección. |
contiene(Objeto o) | Este método devuelve verdadero si la colección contiene el elemento especificado. |
contieneTodo(Colección c) | Este método devuelve verdadero si la colección contiene todos los elementos de la colección dada. |
es igual(Objeto o) | Este método compara el objeto especificado con esta colección para determinar la igualdad. |
código hash() | Este método se utiliza para devolver el valor del código hash para esta colección. |
esta vacio() | Este método devuelve verdadero si esta colección no contiene elementos. |
iterador() | Este método devuelve un iterador sobre los elementos de esta colección. |
máx() | Este método se utiliza para devolver el valor máximo presente en la colección. |
corriente paralela() | Este método devuelve un Stream paralelo con esta colección como fuente. |
eliminar (Objeto o) | Este método se utiliza para eliminar el objeto dado de la colección. Si hay valores duplicados, este método elimina la primera aparición del objeto. |
eliminarTodo(Colección c) | Este método se utiliza para eliminar de la colección todos los objetos mencionados en la colección dada. |
removeIf(filtro de predicado) | Este método se utiliza para eliminar todos los elementos de esta colección que satisfacen los requisitos dados. predicado . |
retenerTodo(Colección c) | Este método se utiliza para conservar solo los elementos de esta colección que están contenidos en la colección especificada. |
tamaño() | Este método se utiliza para devolver la cantidad de elementos de la colección. |
divisor() | Este método se utiliza para crear un Separador sobre los elementos de esta colección. |
arroyo() | Este método se utiliza para devolver una secuencia secuencial con esta colección como fuente. |
a matriz() | Este método se utiliza para devolver una matriz que contiene todos los elementos de esta colección. |
Interfaces que amplían la interfaz de colecciones de Java
El marco de recopilación contiene múltiples interfaces donde cada interfaz se utiliza para almacenar un tipo específico de datos. Las siguientes son las interfaces presentes en el marco.
1. Interfaz iterable
Esta es la interfaz raíz de todo el marco de la colección. La interfaz de colección amplía la interfaz iterable. Por lo tanto, inherentemente, todas las interfaces y clases implementan esta interfaz. La funcionalidad principal de esta interfaz es proporcionar un iterador para las colecciones. Por lo tanto, esta interfaz contiene sólo un método abstracto que es el iterador. Devuelve el
Iterator iterator();>
2. Interfaz de colección
Esta interfaz amplía la interfaz iterable y la implementan todas las clases en el marco de la colección. Esta interfaz contiene todos los métodos básicos que tiene cada colección, como agregar datos a la colección, eliminar datos, borrar datos, etc. Todos estos métodos se implementan en esta interfaz porque estos métodos son implementados por todas las clases independientemente de su estilo. de implementación. Y además, tener estos métodos en esta interfaz garantiza que los nombres de los métodos sean universales para todas las colecciones. Por lo tanto, en resumen, podemos decir que esta interfaz construye una base sobre la cual se implementan las clases de la colección.
3. Interfaz de lista
Esta es una interfaz secundaria de la interfaz de colección. Esta interfaz está dedicada a los datos del tipo lista en la que podemos almacenar todas las colecciones ordenadas de los objetos. Esto también permite que haya datos duplicados en él. Esta interfaz de lista está implementada por varias clases como ArrayList, Vector, Stack, etc. Dado que todas las subclases implementan la lista, podemos crear una instancia de un objeto de lista con cualquiera de estas clases.
Por ejemplo:
List al = new ArrayList (); List ll = new LinkedList (); List v = new Vector (); Where T is the type of the object>
Las clases que implementan la interfaz List son las siguientes:
i). Lista de arreglo
ArrayList nos proporciona matrices dinámicas en Java. Sin embargo, puede ser más lento que los arreglos estándar, pero puede ser útil en programas donde se necesita mucha manipulación en el arreglo. El tamaño de una ArrayList aumenta automáticamente si la colección crece o se reduce si los objetos se eliminan de la colección. Java ArrayList nos permite acceder aleatoriamente a la lista. ArrayList no se puede utilizar para clase contenedora para tales casos.
Entendamos ArrayList con el siguiente ejemplo:
Java
// Java program to demonstrate the> // working of ArrayList> import> java.io.*;> import> java.util.*;> class> GFG {> > // Main Method> > public> static> void> main(String[] args)> > {> > // Declaring the ArrayList with> > // initial size n> > ArrayList al => new> ArrayList();> > // Appending new elements at> > // the end of the list> > for> (> int> i => 1> ; i <=> 5> ; i++)> > al.add(i);> > // Printing elements> > System.out.println(al);> > // Remove element at index 3> > al.remove(> 3> );> > // Displaying the ArrayList> > // after deletion> > System.out.println(al);> > // Printing elements one by one> > for> (> int> i => 0> ; i System.out.print(al.get(i) + ' '); } }> |
>
>Producción
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
ii). Lista enlazada
La clase LinkedList es una implementación de la Entendamos LinkedList con el siguiente ejemplo:
Java
// Java program to demonstrate the> // working of LinkedList> import> java.io.*;> import> java.util.*;> class> GFG {> > // Main Method> > public> static> void> main(String[] args)> > {> > // Declaring the LinkedList> > LinkedList ll => new> LinkedList();> > // Appending new elements at> > // the end of the list> > for> (> int> i => 1> ; i <=> 5> ; i++)> > ll.add(i);> > // Printing elements> > System.out.println(ll);> > // Remove element at index 3> > ll.remove(> 3> );> > // Displaying the List> > // after deletion> > System.out.println(ll);> > // Printing elements one by one> > for> (> int> i => 0> ; i System.out.print(ll.get(i) + ' '); } }> |
>
>Producción
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iii). Vector
Un vector nos proporciona matrices dinámicas en Java. Sin embargo, puede ser más lento que los arreglos estándar, pero puede ser útil en programas donde se necesita mucha manipulación en el arreglo. Esto es idéntico a ArrayList en términos de implementación. Sin embargo, la principal diferencia entre un vector y un ArrayList es que un Vector está sincronizado y un ArrayList no está sincronizado.
Entendamos el Vector con un ejemplo:
Java
// Java program to demonstrate the> // working of Vector> import> java.io.*;> import> java.util.*;> class> GFG {> > // Main Method> > public> static> void> main(String[] args)> > {> > // Declaring the Vector> > Vector v => new> Vector();> > // Appending new elements at> > // the end of the list> > for> (> int> i => 1> ; i <=> 5> ; i++)> > v.add(i);> > // Printing elements> > System.out.println(v);> > // Remove element at index 3> > v.remove(> 3> );> > // Displaying the Vector> > // after deletion> > System.out.println(v);> > // Printing elements one by one> > for> (> int> i => 0> ; i System.out.print(v.get(i) + ' '); } }> |
>
>Producción
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iv). Pila
Modelos de clase de pila e implementa elúltimo en entrar primero en salir. Además de las operaciones básicas de inserción y extracción, la clase proporciona tres funciones más: vaciar, buscar y mirar. La clase también puede denominarse subclase de Vector.
Entendamos la pila con un ejemplo:
Java
// Java program to demonstrate the> // working of a stack> import> java.util.*;> public> class> GFG {> > // Main Method> > public> static> void> main(String args[])> > {> > Stack stack => new> Stack();> > stack.push(> 'Geeks'> );> > stack.push(> 'For'> );> > stack.push(> 'Geeks'> );> > stack.push(> 'Geeks'> );> > // Iterator for the stack> > Iterator itr = stack.iterator();> > // Printing the stack> > while> (itr.hasNext()) {> > System.out.print(itr.next() +> ' '> );> > }> > System.out.println();> > stack.pop();> > // Iterator for the stack> > itr = stack.iterator();> > // Printing the stack> > while> (itr.hasNext()) {> > System.out.print(itr.next() +> ' '> );> > }> > }> }> |
>
>Producción
Geeks For Geeks Geeks Geeks For Geeks>
Nota: Stack es una subclase de Vector y una clase heredada. Es seguro para subprocesos, lo que puede resultar complicado en un entorno donde no se necesita seguridad para subprocesos. Una alternativa a Stack es usar ArrayDequeue que no es seguro para subprocesos y tiene una implementación de matriz más rápida.
4. Interfaz de cola
Como sugiere el nombre, una interfaz de cola mantiene el orden FIFO (primero en entrar, primero en salir) similar a una línea de cola del mundo real. Esta interfaz está dedicada a almacenar todos los elementos donde el orden de los elementos importa. Por ejemplo, cada vez que intentamos reservar un boleto, los boletos se venden por orden de llegada. Por lo tanto, la persona cuya solicitud llega primero a la cola obtiene el billete. Hay varias clases como Cola de prioridad , ArrayDeque , etc. Dado que todas estas subclases implementan la cola, podemos crear una instancia de un objeto de cola con cualquiera de estas clases.
Por ejemplo:
Queue pq = new PriorityQueue (); Queue ad = new ArrayDeque (); Where T is the type of the object.>
La implementación más utilizada de la interfaz de cola es PriorityQueue.
Cola de prioridad
Se utiliza PriorityQueue cuando se supone que los objetos deben procesarse según la prioridad. Se sabe que una cola sigue el algoritmo primero en entrar, primero en salir, pero a veces es necesario procesar los elementos de la cola según la prioridad y en estos casos se utiliza esta clase. PriorityQueue se basa en el montón de prioridades. Los elementos de la cola de prioridad se ordenan según el orden natural, o por un Comparador proporcionado en el momento de la construcción de la cola, dependiendo del constructor que se utilice.
Entendamos la cola de prioridad con un ejemplo:
Java
// Java program to demonstrate the working of> // priority queue in Java> import> java.util.*;> class> GfG {> > // Main Method> > public> static> void> main(String args[])> > {> > // Creating empty priority queue> > PriorityQueue pQueue> > => new> PriorityQueue();> > // Adding items to the pQueue using add()> > pQueue.add(> 10> );> > pQueue.add(> 20> );> > pQueue.add(> 15> );> > // Printing the top element of PriorityQueue> > System.out.println(pQueue.peek());> > // Printing the top element and removing it> > // from the PriorityQueue container> > System.out.println(pQueue.poll());> > // Printing the top element again> > System.out.println(pQueue.peek());> > }> }> |
>
>Producción
10 10 15>
5. y la interfaz
Esta es una variación muy ligera de la Por ejemplo:
Deque ad = new ArrayDeque (); Where T is the type of the object.>
La clase que implementa la interfaz deque es ArrayDeque.
ArrayDeque
La clase ArrayDeque que se implementa en el marco de la colección nos proporciona una forma de aplicar una matriz de tamaño variable. Este es un tipo especial de matriz que crece y permite a los usuarios agregar o eliminar un elemento de ambos lados de la cola. Los deques de matriz no tienen restricciones de capacidad y crecen según sea necesario para admitir el uso.
Entendamos ArrayDeque con un ejemplo:
Java
// Java program to demonstrate the> // ArrayDeque class in Java> import> java.util.*;> public> class> ArrayDequeDemo {> > public> static> void> main(String[] args)> > {> > // Initializing an deque> > ArrayDeque de_que> > => new> ArrayDeque(> 10> );> > // add() method to insert> > de_que.add(> 10> );> > de_que.add(> 20> );> > de_que.add(> 30> );> > de_que.add(> 40> );> > de_que.add(> 50> );> > System.out.println(de_que);> > // clear() method> > de_que.clear();> > // addFirst() method to insert the> > // elements at the head> > de_que.addFirst(> 564> );> > de_que.addFirst(> 291> );> > // addLast() method to insert the> > // elements at the tail> > de_que.addLast(> 24> );> > de_que.addLast(> 14> );> > System.out.println(de_que);> > }> }> |
>
>Producción
[10, 20, 30, 40, 50] [291, 564, 24, 14]>
6. Establecer interfaz
Un conjunto es una colección desordenada de objetos en la que no se pueden almacenar valores duplicados. Esta colección se utiliza cuando deseamos evitar la duplicación de los objetos y deseamos almacenar solo los objetos únicos. Esta interfaz de conjunto se implementa mediante varias clases como HashSet, TreeSet, LinkedHashSet, etc. Dado que todas las subclases implementan el conjunto, podemos crear una instancia de un objeto de conjunto con cualquiera de estas clases.
Por ejemplo:
Set hs = new HashSet (); Set lhs = new LinkedHashSet (); Set ts = new TreeSet (); Where T is the type of the object.>
Las siguientes son las clases que implementan la interfaz Set:
i). Conjunto de hash
La clase HashSet es una implementación inherente de la estructura de datos de la tabla hash. Los objetos que insertamos en el HashSet no garantizan que se inserten en el mismo orden. Los objetos se insertan según su código hash. Esta clase también permite la inserción de elementos NULL. Entendamos HashSet con un ejemplo:
Java
// Java program to demonstrate the> // working of a HashSet> import> java.util.*;> public> class> HashSetDemo {> > // Main Method> > public> static> void> main(String args[])> > {> > // Creating HashSet and> > // adding elements> > HashSet hs => new> HashSet();> > hs.add(> 'Geeks'> );> > hs.add(> 'For'> );> > hs.add(> 'Geeks'> );> > hs.add(> 'Is'> );> > hs.add(> 'Very helpful'> );> > // Traversing elements> > Iterator itr = hs.iterator();> > while> (itr.hasNext()) {> > System.out.println(itr.next());> > }> > }> }> |
>
>Producción
Very helpful Geeks For Is>
ii). LinkedHashSet
Un LinkedHashSet es muy similar a un HashSet. La diferencia es que este utiliza una lista doblemente enlazada para almacenar los datos y conserva el orden de los elementos.
Entendamos LinkedHashSet con un ejemplo:
Java
// Java program to demonstrate the> // working of a LinkedHashSet> import> java.util.*;> public> class> LinkedHashSetDemo {> > // Main Method> > public> static> void> main(String args[])> > {> > // Creating LinkedHashSet and> > // adding elements> > LinkedHashSet lhs> > => new> LinkedHashSet();> > lhs.add(> 'Geeks'> );> > lhs.add(> 'For'> );> > lhs.add(> 'Geeks'> );> > lhs.add(> 'Is'> );> > lhs.add(> 'Very helpful'> );> > // Traversing elements> > Iterator itr = lhs.iterator();> > while> (itr.hasNext()) {> > System.out.println(itr.next());> > }> > }> }> |
>
>Producción
Geeks For Is Very helpful>
7. Interfaz de conjunto ordenado
Esta interfaz es muy similar a la interfaz establecida. La única diferencia es que esta interfaz tiene métodos adicionales que mantienen el orden de los elementos. La interfaz del conjunto ordenado amplía la interfaz del conjunto y se utiliza para manejar los datos que deben ordenarse. La clase que implementa esta interfaz es TreeSet. Dado que esta clase implementa SortedSet, podemos crear una instancia de un objeto SortedSet con esta clase.
Por ejemplo:
SortedSet ts = new TreeSet (); Where T is the type of the object.>
La clase que implementa la interfaz de conjunto ordenado es TreeSet.
Conjunto de árboles
La clase TreeSet utiliza un árbol para almacenamiento. El orden de los elementos lo mantiene un conjunto que utiliza su orden natural, ya sea que se proporcione o no un comparador explícito. Esto debe ser consistente con iguales si se quiere implementar correctamente la interfaz Set. También puede ser ordenado por un Comparador proporcionado en un momento de creación establecido, dependiendo del constructor que se utilice.
Entendamos TreeSet con un ejemplo:
Java
// Java program to demonstrate the> // working of a TreeSet> import> java.util.*;> public> class> TreeSetDemo {> > // Main Method> > public> static> void> main(String args[])> > {> > // Creating TreeSet and> > // adding elements> > TreeSet ts => new> TreeSet();> > ts.add(> 'Geeks'> );> > ts.add(> 'For'> );> > ts.add(> 'Geeks'> );> > ts.add(> 'Is'> );> > ts.add(> 'Very helpful'> );> > // Traversing elements> > Iterator itr = ts.iterator();> > while> (itr.hasNext()) {> > System.out.println(itr.next());> > }> > }> }> |
>
>Producción
For Geeks Is Very helpful>
8. Interfaz de mapa
Un mapa es una estructura de datos que admite el par clave-valor para mapear los datos. Esta interfaz no admite claves duplicadas porque la misma clave no puede tener múltiples asignaciones; sin embargo, permite valores duplicados en claves diferentes. Un mapa es útil si hay datos y queremos realizar operaciones en base a la clave. Esta interfaz de mapa está implementada por varias clases como HashMap , ÁrbolMapa , etc. Dado que todas las subclases implementan el mapa, podemos crear una instancia de un objeto de mapa con cualquiera de estas clases.
Por ejemplo:
Map hm = new HashMap (); Map tm = new TreeMap (); Where T is the type of the object.>
La implementación más utilizada de una interfaz Map es un HashMap.
HashMap
HashMap proporciona la implementación básica de la interfaz Map de Java. Almacena los datos en pares (clave, valor). Para acceder a un valor en un HashMap, debemos conocer su clave. HashMap utiliza una técnica llamada Hashing. Hashing es una técnica de convertir una cadena grande en una cadena pequeña que representa la misma cadena para que las operaciones de indexación y búsqueda sean más rápidas. HashSet también usa HashMap internamente.
Entendamos el HashMap con un ejemplo:
Java
// Java program to demonstrate the> // working of a HashMap> import> java.util.*;> public> class> HashMapDemo {> > // Main Method> > public> static> void> main(String args[])> > {> > // Creating HashMap and> > // adding elements> > HashMap hm> > => new> HashMap();> > hm.put(> 1> ,> 'Geeks'> );> > hm.put(> 2> ,> 'For'> );> > hm.put(> 3> ,> 'Geeks'> );> > // Finding the value for a key> > System.out.println(> 'Value for 1 is '> + hm.get(> 1> ));> > // Traversing through the HashMap> > for> (Map.Entry e : hm.entrySet())> > System.out.println(e.getKey() +> ' '> > + e.getValue());> > }> }> |
>
>Producción
Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>