ArrayList es parte del marco de la colección y está presente en el paquete java.util . Nos proporciona arreglos dinámicos en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. HashMap es parte de la colección de Java desde Java 1.2. Proporciona la implementación básica de la interfaz Map de Java. Almacena los datos en pares (Clave, Valor), y para acceder a un valor, uno debe conocer su clave. HashMap se conoce como HashMap porque utiliza una técnica llamada Hashing.
Hashing es una técnica de convertir una string grande en una string pequeña que representa la misma string. Un valor más corto ayuda en la indexación y búsquedas más rápidas. HashSet también usa HashMap internamente. Utiliza internamente una lista de enlaces para almacenar pares clave-valor ya explicados en detalle en HashSet y otros artículos.
Aquí procederemos discutiendo las características comunes compartidas entre ellos. Luego discutiremos las diferencias entre ellos realizando conjuntos de operaciones sobre ambos en un solo programa Java y percibiendo las diferencias entre los resultados.
Primero, analicemos las similitudes entre ArrayList y HashMap en Java
- ArrayList y HashMap, ambos no están sincronizados. Entonces, para usarlos en el entorno de subprocesos múltiples, primero debe sincronizarse.
- Tanto ArrayList como HashMap permiten nulo. ArrayList permite valores nulos y HashMap permite claves y valores nulos
- Tanto ArrayList como HashMap permiten duplicados, ArrayList permite elementos duplicados y HashMap permite valores duplicados
- Tanto ArrayList como HashMap se pueden recorrer a través de Iterator en Java.
- Ambos Somewhere usan una array, ArrayList está respaldado por una array y HashMap también está implementado internamente por Array
- Ambos usan el método get() , el método ArrayList.get() funciona en base a un índice, y el método HashMap.get() toma un parámetro key_element del tipo de objeto y se refiere a la clave cuyo valor asociado se supone que debe obtenerse, por lo que ambos proporcionan rendimiento en tiempo constante.
Con mucho, obtenemos algo de claridad de los medios proporcionados anteriormente y ahora realizaremos conjuntos de operaciones sobre ellos para percibir diferencias reales a través de diferencias finales en los resultados sobre la misma operación, lo que aumenta nuestro intelecto para comprender las diferencias entre ArrayList y HashMap.
- Jerarquía junto con la sintaxis
- Mantenimiento de orden de inserción
- Consumo de memoria
- Manejo de elementos duplicados
- Facilidad de obtener un elemento
- Almacenamiento de elementos nulos
Diferencias entre ArrayList y HashMap en Java
1. Jerarquía junto con la sintaxis
Interfaz implementada: ArrayList implementa la interfaz de lista , mientras que HashMap es la implementación de la interfaz de mapa .
Sintaxis: declaración de la clase ArrayList
public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable
Sintaxis: declaración de la clase HashMap
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
2. Mantenimiento de la Orden de Inserción
ArrayList mantiene el orden de inserción, mientras que HashMap no mantiene el orden de inserción, lo que significa que ArrayList devuelve los elementos de la lista en el mismo orden, mientras que HashMap no mantiene ningún orden, por lo que devuelve pares clave-valor en cualquier tipo de orden.
Ejemplo:
Java
// Java Program to illustrate Maintenance of Insertion Order
// in ArrayList vs HashMap
// Importing all utility classes
import java.util.*;
// Main class
class GFG {
// Main driver method
public static void main(String args[])
{
// Creating ArrayList of string type
ArrayList<String> list = new ArrayList<String>();
// Adding object in ArrayList
list.add("A");
list.add("B");
list.add("C");
list.add("D");
// Invoking ArrayList object
System.out.println("ArrayList: " + list);
// Creating HashMap
HashMap<Integer, String> hm
= new HashMap<Integer, String>();
// Adding object in HashMap object created above
// using put() method
hm.put(1, "A");
hm.put(2, "B");
hm.put(3, "C");
hm.put(4, "D");
// Invoking HashMap object
// It might or might not display elements
// in the insertion order
System.out.print("Hash
Map: " + hm);
}
}
ArrayList: [A, B, C, D]
HashMap: {1=A, 2=B, 3=C, 4=D}
3. Consumo de memoria
ArrayList almacena los elementos solo como valores y mantiene internamente la indexación de cada elemento. Mientras que HashMap almacena elementos con pares de clave y valor, eso significa dos objetos. Entonces HashMap toma más memoria comparativamente.
Sintaxis: ArrayList
list.add("A");
// String value is stored in ArrayList
Sintaxis: HashMap
hm.put(1, "A"); // Two String values stored // as the key value pair in HashMap
4. Manejo de elementos duplicados
ArrayList permite elementos duplicados, mientras que HashMap no permite claves duplicadas pero sí valores duplicados.
Ejemplo
Java
// Java Program to Illustrate Duplicate Elements Insertion
// in ArrayList vs HashMap
// Importing utility classes
import java.util.*;
// Main class
class GFG {
// Main driver method
public static void main(String args[])
{
// Creating ArrayList of string type
ArrayList<String> list = new ArrayList<String>();
// Adding object in ArrayList
list.add("A");
list.add("B");
// Add duplicates
list.add("A");
list.add("A");
// Invoking ArrayList object
System.out.println("ArrayList: " + list);
// Creating HashMap
HashMap<Integer, String> hm
= new HashMap<Integer, String>();
// Adding object in HashMap
hm.put(1, "A");
hm.put(2, "B");
// Add duplicates key
// Change value if index exist
hm.put(3, "A");
hm.put(3, "A");
// Add duplicates values
// allow duplicates value
hm.put(4, "A");
hm.put(5, "A");
// Invoking HashMap object
System.out.print("HashMap: " + hm);
}
}
ArrayList: [A, B, A, A]
HashMap: {1=A, 2=B, 3=A, 4=A, 5=A}
5. Facilidad para buscar un elemento
En ArrayList, un elemento se puede obtener fácilmente especificando su índice. Pero en HashMap, los elementos se obtienen por su clave correspondiente. Significa que la clave debe recordarse siempre.
Nota: el método ArrayList get(index) siempre da una complejidad de tiempo O(1), mientras que HashMap get(key) puede ser O(1) en el mejor de los casos y O(n) en el peor de los casos.
Ejemplo
Java
// Java Program to Illustrate Ease of fetching an Element
// in ArrayList vs HashMap
// Importing all utility classes
import java.util.*;
// Main class
class GFG {
// main driver method
public static void main(String args[])
{
// Creating ArrayList of string type
ArrayList<String> list = new ArrayList<String>();
// Adding object in ArrayList
list.add("A");
list.add("B");
list.add("C");
list.add("D");
// Invoking ArrayList object
System.out.println("First Element of ArrayList: "
+ list.get(0));
System.out.println("Third Element of ArrayList: "
+ list.get(2));
// Creating HashMap
// Declaring object of integer and string type
HashMap<Integer, String> hm
= new HashMap<Integer, String>();
// Adding object in HashMap
hm.put(1, "A");
hm.put(2, "B");
hm.put(3, "C");
hm.put(4, "D");
// Invoking HashMap object
System.out.println("HashMap value at Key 1: "
+ hm.get(1));
System.out.println("HashMap value at Key 3: "
+ hm.get(3));
}
}
First Element of ArrayList: A Third Element of ArrayList: C HashMap value at Key 1: A HashMap value at Key 3: C
6. Almacenamiento de elementos nulos
En ArrayList, se puede almacenar cualquier número de elementos nulos. Mientras está en HashMap, solo se permite una clave nula, pero los valores pueden ser de cualquier número.
Ejemplo
Java
// Java Program to Illustrate Null Element Storage in
// Arraylist vs HashMap
// Importing all utility classes
import java.util.*;
// Main class
class GFG {
// main driver method
public static void main(String args[])
{
// Creating ArrayList of string type
ArrayList<String> list = new ArrayList<String>();
// Adding object in ArrayList
// using standard add() method
list.add("A");
// Adding first null value
list.add(null);
list.add("C");
// Adding two null value again
list.add(null);
list.add(null);
// Invoking ArrayList object
System.out.println("ArrayList: " + list);
// Creating HashMap
// Declaring object of integer and string type
HashMap<Integer, String> hm
= new HashMap<Integer, String>();
// Adding object in HashMap
hm.put(1, "A");
hm.put(2, "B");
// add null key
hm.put(null, "C");
// Again adding null key
// which replace value of first
// insert null key value
hm.put(null, null);
// Adding second null value
hm.put(3, null);
// Printing the elements of Hashmap
System.out.println("HashMap: " + hm);
}
}
ArrayList: [A, null, C, null, null]
HashMap: {null=null, 1=A, 2=B, 3=null}
Entonces, averigüemos las diferencias entre ArrayList y HashMap en una tabla:
|
Lista de arreglo |
mapa hash |
|---|---|
| Java ArrayList implementa la interfaz de lista |
Java HashMap implementa la interfaz Map |
| ArrayList siempre mantiene el orden de inserción de los elementos |
HashMap no mantiene el orden de inserción. |
| ArrayList solo almacena valor o elemento |
HashMap almacena pares de clave y valor |
| ArrayList puede contener elementos duplicados |
HashMap no contiene claves duplicadas pero contiene valores duplicados. |
| Podemos tener cualquier número de elementos nulos en ArrayList |
Solo podemos tener una clave nula y cualquier número de valores nulos en HashMap |
| El método ArrayList get() siempre da un rendimiento O(1) |
El método HashMap get() puede ser O(1) en el mejor de los casos y O(n) en el peor de los casos |