¿Cuál es la diferencia entre los objetos HashMap y Map en Java?

Map es una interfaz que HashMap implementa. La diferencia es que en la segunda implementación su referencia al HashMap solo permitirá el uso de funciones definidas en la interfaz del Mapa, mientras que la primera permitirá el uso de cualquier función pública en HashMap (que incluye la interfaz del mapa).

Probablemente tendrá más sentido si lees El tutorial de la interfaz de Sun

Yo solo iba a hacer esto como un comentario sobre la respuesta aceptada, pero se puso demasiado funky (odio no tener saltos de línea)

Ah, entonces la diferencia es que en general, el mapa tiene ciertos métodos asociado con él. pero hay diferentes formas o crear un mapa, tales como un HashMap, y estas diferentes formas proporcionar métodos únicos que no todos los mapas sí.

Exactamente and y siempre quieres usar la interfaz más general que puedas. Considere ArrayList vs LinkedList. Gran diferencia en cómo los usas, pero si usas "Lista" puedes cambiar entre ellos fácilmente.

De hecho, puede reemplazar el lado derecho del inicializador con una instrucción más dinámica. ¿algo como esto:

List collection;
if(keepSorted)
    collection=new LinkedList();
else
    collection=new ArrayList();

De esta manera, si va a llenar la colección con una ordenación de inserción, utilizará una lista vinculada (una ordenación de inserción en una lista de matrices es criminal.) Pero si no necesita mantenerlo ordenado y solo está anexando, use un ArrayList (Más eficiente para otras operaciones).

Este es un tramo bastante grande aquí porque las colecciones no son el mejor ejemplo, pero en el diseño OO uno de los conceptos más importantes es usar la fachada de la interfaz para acceder a diferentes objetos con el mismo código exacto.

Editar respuesta al comentario:

En cuanto a su comentario de mapa a continuación, Sí, el uso de la interfaz "Mapa" lo restringe a solo esos métodos a menos que vuelva a enviar la colección de Mapa a HashMap (lo que frustra completamente el propósito).

A menudo lo que hará es crear un objeto y rellenarlo usando su tipo específico (HashMap), en algún tipo de método "create" o "initialize", pero ese método devolverá un "Map" que ya no necesita ser manipulado como un HashMap.

Si alguna vez tiene que enviar por cierto, probablemente esté utilizando la interfaz incorrecta o su código no está suficientemente estructurado. Tenga en cuenta que es aceptable que una sección de su código lo trate como un "HashMap" mientras que el otro lo trata como un" Mapa", pero esto debería fluir"hacia abajo". para que nunca hagas el casting.

También observe el aspecto semi-limpio de los roles indicados por las interfaces. Una LinkedList hace una buena pila o cola, un ArrayList hace una buena pila pero un terrible cola (de nuevo, quitar podría causar un desplazamiento de toda la lista) para LinkedList implementa la interfaz de Cola, ArrayList no.

Map having following implementations,

1. HashMap Map m = new HashMap();

2. LinkedHashMap Map m = new LinkedHashMap();

3. Mapa de Árbol Map m = new TreeMap();

4. WeakHashMap Map m = new WeakHashMap();

Supongamos que ha creado un método (es solo código spudo).

public void HashMap getMap(){
   return map;
}

Supongamos que los requisitos del proyecto cambian cada vez de la siguiente manera,

1. El método debe devolver el contenido del mapa-Es necesario devolver HashMap.
2. El método debe devolver las claves del mapa en orden de inserción - Es necesario cambiar el tipo de retorno HashMap a LinkedHashMap.
3. El método debe devolver las claves del mapa en orden ordenado - Es necesario cambiar el tipo de retorno LinkedHashMap a TreeMap.

Si su método devuelve clases específicas en lugar de la interfaz Map, debe cambiar el tipo de retorno del método getMap() cada vez.

Pero, si utiliza polimorfismo característica de java, en lugar de devolver la clase específica utilizada interfaz Map, Conduce a la reutilización del código y menos impacto si cualquier cambio de requisito.

Como señalan TJ Crowder y Adamski, una referencia es a una interfaz, la otra a una implementación específica de la interfaz. Según Joshua Block, siempre debe intentar codificar interfaces, para permitirle manejar mejor los cambios en la implementación subyacente, es decir, si HashMap repentinamente no era ideal para su solución y necesitaba cambiar la implementación del mapa, aún podría usar la interfaz del mapa y cambiar el tipo de instanciación.

En su segundo ejemplo, la referencia "map" es de tipo Map, que es una interfaz implementada por HashMap (y otros tipos de Map). Esta interfaz es un contrato que dice que el objeto asigna claves a valores y soporta varias operaciones (p.ej. put, get). No dice nada sobre la implementación del Map (en este caso a HashMap).

Generalmente se prefiere el segundo enfoque, ya que normalmente no desea exponer la implementación de mapa específica a métodos que utilizan Map o a través de una definición de API.

Map es el tipo estáticode map, mientras que HashMap es el tipo dinámico de map. Esto significa que el compilador tratará su objeto map como uno de tipo Map, aunque en tiempo de ejecución, puede apuntar a cualquier subtipo del mismo.

Esta práctica de programación contra interfaces en lugar de implementaciones tiene el beneficio añadido de permanecer flexible: Puede, por ejemplo, reemplazar el tipo dinámico de mapa en tiempo de ejecución, siempre y cuando sea un subtipo de mapa (por ejemplo, LinkedHashMap), y cambia el comportamiento del mapa sobre la marcha.

Una buena regla general es permanecer lo más abstracto posible en el nivel de API: Si, por ejemplo, un método que está programando debe funcionar en mapas, entonces es suficiente declarar un parámetro como Mapa en lugar del tipo HashMap más estricto (porque menos abstracto). De esa manera, el consumidor de su API puede ser flexible sobre qué tipo de implementación de mapas desea pasar a su método.

Se crean los mismos mapas.

Pero puedes rellenar la diferencia cuando la utilices. Con el primer caso podrás usar métodos HashMap especiales (pero no recuerdo a nadie realmente útil), y podrás pasarlo como un parámetro HashMap:

public void foo (HashMap<String, Object) { ... }

...

HashMap<String, Object> m1 = ...;
Map<String, Object> m2 = ...;

foo (m1);
foo ((HashMap<String, Object>)m2); 

Añadiendo a la respuesta votada arriba y a muchas anteriores haciendo hincapié en el "más genérico, mejor", me gustaría profundizar un poco más.

Map es el contrato de estructura mientras que HashMap es una implementación que proporciona sus propios métodos para lidiar con diferentes problemas reales: cómo calcular el índice, cuál es la capacidad y cómo aumentarla, cómo insertar, cómo mantener el índice único, etc.

Veamos el código fuente:

En Map tenemos el método de containsKey(Object key):

boolean containsKey(Object key);

JavaDoc:

Java booleano.útil.Asignar.containsValue (Valor del objeto)

Devuelve true si este mapa asigna una o más claves al valor especificado. Más formalmente, devuelve true si y solo si este mapa contiene al menos una asignación a un valor v tal que (value==null ? v==null : value.equals(v)). Esta operación probablemente requerirá tiempo lineal en el tamaño del mapa para la mayoría de las implementaciones de la interfaz del mapa.

Parámetros: valor

Valor cuya presencia en este mapa es para betested

Devuelve: true

Si este mapa asigna una o más claves a la

El valor aumenta:

ClassCastException - si el valor es de tipo inadecuado para este mapa (opcional)

NullPointerException-si el valor especificado es null y este mapa no permite valores null (opcional)

Requiere sus implementaciones para implementarlo, pero el" cómo " está en su libertad, solo para garantizar devuelve correcto.

En HashMap:

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

Resulta que HashMap usa hashcode para probar si este mapa contiene la clave. Así que tiene el beneficio del algoritmo hash.

Map es la interfaz y Hashmap es la clase que implementa eso.

Así que en esta implementación se crean los mismos objetos

Map es interfaz y Hashmap es una clase que implementa Map Interfaz

HashMap es una implementación de Map, por lo que es bastante igual, pero tiene el método " clone ()"como veo en la guía de referencia))

HashMap<String, Object> map1 = new HashMap<String, Object>();
Map<String, Object> map2 = new HashMap<String, Object>();  

En primer lugar Map es una interfaz que tiene una implementación diferente como - HashMap, TreeHashMap, LinkedHashMap etc. La interfaz funciona como una súper clase para la clase de implementación. Así que de acuerdo con la regla de OOP cualquier clase concreta que implementa Map es un Map también. Eso significa que podemos asignar / poner cualquier variable de tipo HashMap a una variable de tipo Map sin ningún tipo de fundición.

En este caso podemos asignar map1 a map2 sin ningún casting o pérdida de datos -

map2 = map1