Mapa abstracto en Java

La clase AbstractMap es parte de Java Collection Framework . Implementa directamente la interfaz Map para proporcionarle una estructura, al hacerlo, facilita las implementaciones posteriores. Como sugiere el nombre, AbstractMap es una clase abstracta por definición, por lo tanto, no se puede usar para crear objetos. Las clases concretas que heredan de AbstractMap se pueden usar para crear objetos.

Declaración:

public abstract class AbstractMap<K,V> extends Object, implements Map<K,V>

Aquí, K es el tipo de clave y V es el tipo de valor.

Jerarquía de AbstractMap

Esta clase implementa la interfaz Map<K, V> y extiende la clase Object .

Constructores de AbstractMap

Operaciones básicas

1. Agregar elementos

Para agregar elementos a un AbstractMap usamos el método put() . Tenga en cuenta que el método no es realmente del tipo AbstractMap sino de una clase extendida, la referencia a este objeto es del tipo AbstractMap. Las entradas del mapa son de tipo clave, par de valores. Aquí la clave es de tipo Integer y el valor id de tipo String, esto se menciona en el momento de la instanciación del objeto.

// Java Program to demonstrate adding
// elements to the AbstractMap
  
import java.util.*;
  
public class AddElements {
  
    public static void main(String[] args)
    {
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();
  
        // Adding values to the AbstractMap
        // Note that we do not create an object of
        // AbstractMap
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "an");
        absMap.put(4, "AbstractMap");
  
        // Displaying the mappings using
        // entrySet() to get the set view
        System.out.println("The Set view of the mappings:");
        System.out.println(absMap.entrySet());
    }
}

The Set view of the mappings:
[1=This, 2=is, 3=an, 4=AbstractMap]

2. Eliminación de elementos

Podemos eliminar asignaciones de un AbstractMap usando el método remove() . La sintaxis de eliminar es 

mapName.remove(Object key);

Esto eliminará el valor asignado a la clave especificada. Podemos borrar todo el AbstractMap usando el método clear() como se muestra a continuación.

// Java Program to demonstrate removing
// elements from the AbstractMap
  
import java.util.*;
  
public class RemoveElements {
  
    public static void main(String[] args)
    {
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();
  
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "an");
        absMap.put(4, "AbstractMap");
  
        // Displaying the mappings
        System.out.println("Mappings of the AbstractMap:");
        System.out.println(absMap);
  
        // Removing an entry using the remove() method
        absMap.remove(1);
  
        // Displaying the mappings
        System.out.println("Mappings of the AbstractMap:");
        System.out.println(absMap);
  
        // Clearing the whole map using clear()
        absMap.clear();
  
        // Displaying the mappings
        System.out.println("\nThe Set view of the mappings:");
        System.out.println(absMap);
    }
}

Mappings of the AbstractMap:
{1=This, 2=is, 3=an, 4=AbstractMap}
Mappings of the AbstractMap:
{2=is, 3=an, 4=AbstractMap}

The Set view of the mappings:
{}

3. Sustitución de entradas

Podemos reemplazar los valores asociados con una clave usando el método replace() como se muestra a continuación.

// Java Program to demonstrate replacing
// elements of AbstractMap
  
import java.util.AbstractMap;
import java.util.HashMap;
  
public class ReplaceElements {
  
    public static void main(String[] args)
    {
  
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();
  
        // Adding values to the AbstractMap
        // Note that we do not create an object of
        // AbstractMap
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "a");
        absMap.put(4, "AbstractMap");
  
        // Displaying the mappings
        System.out.println("Mappings of the AbstractMap:");
        System.out.println(absMap);
  
        // Replacing the mapping associated to 3
        absMap.replace(3, "an");
  
        // Displaying the mappings
        System.out.println("\nMappings of the AbstractMap:");
        System.out.println(absMap);
    }
}

Mappings of the AbstractMap:
{1=This, 2=is, 3=a, 4=AbstractMap}

Mappings of the AbstractMap:
{1=This, 2=is, 3=an, 4=AbstractMap}

4. Atravesando

Hay diferentes formas de atravesar un AbstractMap, discutimos dos formas en el código que se proporciona a continuación. El primer método es usar el método entrySet() , que devuelve una vista de colección del mapa. Esta vista se puede iterar mediante el uso de un bucle for each. El método getKey() devuelve la clave y getValue() devuelve el valor asociado. El segundo método es mediante el uso de la interfaz Iterator. Creamos un iterador sobre el conjunto de claves usando el método keySet() . Este iterador se usa para iterar sobre el mapa usando el método next(), que devuelve la siguiente entrada en el mapa.

// Java Program to demonstrate
// traversing AbstractMap
  
import java.util.*;
  
public class Traversing {
  
    public static void main(String[] args)
    {
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();
  
        // Adding values to the AbstractMap
        // Note that we do not create an object of
        // AbstractMap
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "a");
        absMap.put(4, "AbstractMap");
  
        // METHOD 1
        // Iterate over the map using entrySet()
        // which returns a collection view of the map
  
        System.out.println("Using the entrySet() method");
  
        for (AbstractMap.Entry<Integer, String> entry :
             absMap.entrySet()) {
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
  
        // METHOD 2
        // Iterate over the map using the Iterator interface
  
        System.out.println(
            "\nUsing the Iterator interface");
  
        Iterator<Integer> itr = absMap.keySet().iterator();
        while (itr.hasNext()) {
            int key = itr.next();
            System.out.println("Key = " + key
                               + ", Value =  "
                               + absMap.get(key));
        }
    }
}

Using the entrySet() method
Key = 1, Value = This
Key = 2, Value = is
Key = 3, Value = a
Key = 4, Value = AbstractMap

Using the Iterator interface
Key = 1, Value =  This
Key = 2, Value =  is
Key = 3, Value =  a
Key = 4, Value =  AbstractMap

clases heredadas

1. Mapa hash

La clase HashMap es la implementación básica de la interfaz Map , que almacena los pares clave-valor. HashMap es una implementación de mapa básica de Hashtable, pero HashMap no está sincronizado. El orden de los elementos de un HashMap no está definido. El HashMap proporciona un rendimiento de tiempo constante para las operaciones básicas de inserción, eliminación, recorrido y manipulación.

Sintaxis:

HashMap< ? , ? > hmName = new HashMap< ? , ? >();

2. Mapa de hash de identidad

IdentityHashMap es la implementación de Hashtable de Map , pero usa la igualdad de referencia en lugar de la igualdad de objetos. Lo que significa que IdentityHashMap viola la regla básica de los mapas, por lo tanto, no es un mapa de propósito general, está reservado para escenarios raros. En un IdentityHashMap, dos objetos cualquiera, o1 y o2, son iguales si y solo si o1==o2, es decir, la referencia de o1 y o2 es la misma.

Sintaxis:

IdentityHashMap< ? , ? > ihmName = new IdentityHashMap< ? , ? >();

3. Mapa hash débil

WeakHashMap es una implementación de Hashtable de la interfaz Map que utiliza claves débiles. Cuando una clave en un WeakHashMap ya no se usa normalmente, se descartará automáticamente. Significa que la existencia de una asignación no evitará que la clave se recopile como basura. WeakHashMap es una clase no sincronizada.

Sintaxis:

WeakHashMap< ? , ? > whmName = new WeakHashMap< ? , ? >();

4. Mapa de árbol

La clase TreeMap es una implementación basada en un árbol rojo-negro de NavigableMap . Los elementos de TreeMap se ordenan por orden natural o por el comparador proporcionado en el momento de la construcción.

Sintaxis:

TreeMap< ? , ? > tmName = new TreeMap< ? , ? >();

5. Mapa de enumeración

El EnumMap es una implementación especializada de la interfaz Map . Las claves del EnumMap son de tipo enum. Todas las claves deben ser de la misma enumeración, ya sea definida explícita o implícitamente, especificada en el momento de la construcción. El EnumMap se representa internamente como una array, es muy compacto y eficiente.

Sintaxis:

EnumMap< enumName, ? > emName = new EnumMap< enumName, ? >();

6. Mapa hash concurrente

ConcurrentHashMap es una implementación de Hashtable que admite la simultaneidad total a través de operaciones de recuperación y actualización . Esta clase es altamente compatible con la clase Hashtable y contiene todos los métodos correspondientes de Hashtable. Aunque las operaciones son seguras para subprocesos, no existe un mecanismo de bloqueo, por lo que la recuperación puede superponerse a la actualización. Por lo tanto, las operaciones de recuperación reflejan las operaciones de actualización completadas más recientemente.

Sintaxis:

ConcurrentHashMap< ? , ? > chmName = new ConcurrentHashMap< ? , ? >();

7. Mapa de listas de saltos simultáneos

ConcurrentSkipListMap es una implementación escalable de la interfaz ConcurrentNavigableMap . Las claves en ConcurrentSkipListMap se clasifican por orden natural o mediante el uso de un comparador en el momento de la construcción del objeto. El ConcurrentSkipListMap tiene el costo de tiempo esperado de inicio de sesión para las operaciones de inserción, eliminación y búsqueda. Es una clase segura para subprocesos, por lo tanto, todas las operaciones básicas se pueden realizar al mismo tiempo.

Sintaxis:

ConcurrentSkipListMap< ? , ? > cslmName = new ConcurrentSkipListMap< ? , ? >();

Métodos de AbstractMap

Métodos declarados en la interfaz java.util.Map