Mapa inmutable en Java

Posted on by Rudeus Greyrat
  • ImmutableMap, como sugiere el nombre, es un tipo de mapa que es inmutable. Significa que el contenido del mapa es fijo o constante después de la declaración, es decir, son de solo lectura .
  • Si se intenta agregar, eliminar y actualizar elementos en el mapa, se lanza la excepción UnsupportedOperationException .
  • Un ImmutableMap tampoco permite elementos nulos.
  • Si se intenta crear un ImmutableMap con un elemento nulo, se lanza NullPointerException . Si se intenta agregar un elemento nulo en el mapa, se lanza la excepción UnsupportedOperationException .

Ventajas de ImmutableMap

  • Son seguros para subprocesos.
  • Son eficientes en memoria.
  • Dado que son inmutables, pueden transferirse a bibliotecas de terceros sin ningún problema.

Tenga en cuenta que es una colección inmutable, no una colección de objetos inmutables, por lo que los objetos que contiene pueden modificarse.
Declaración de clase:

@GwtCompatible(serializable=true,
               emulated=true)
public abstract class ImmutableMap
extends Object
implements Map, Serializable

Jerarquía de clases:

java.lang.Object
  ↳ com.google.common.collect.ImmutableMap

Creación de ImmutableMap
ImmutableMap se puede crear mediante varios métodos. Éstos incluyen:

  1. Desde el mapa existente usando la función copyOf() de Guayaba

    // Below is the Java program to create ImmutableMap
      
    import com.google.common.collect.ImmutableMap;
    import java.util.HashMap;
    import java.util.Map;
      
    class MapUtil {
      
        // Function to create ImmutableMap from Map
        public static <K, T> void iMap(Map<K, T> map)
        {
            // Create ImmutableMap from Map using copyOf()
            ImmutableMap<K, T> immutableMap = ImmutableMap.copyOf(map);
      
            // Print the ImmutableMap
            System.out.println(immutableMap);
        }
      
        public static void main(String[] args)
        {
            Map<Integer, String> map = new HashMap<Integer, String>();
            map.put(1, "Geeks");
            map.put(2, "For");
            map.put(3, "Geeks");
            iMap(map);
        }
    }

    Producción:

    {1=Geeks, 2=For, 3=Geeks}
  2. Nuevo ImmutableMap usando la función of() de Guava

    // Below is the Java program to create ImmutableMap
    import com.google.common.collect.ImmutableMap;
    import java.util.HashMap;
    import java.util.Map;
      
    class MapUtil {
      
        // Function to create ImmutableMap
        public static void createImmutableMap()
        {
            // Create ImmutableMap using of()
            ImmutableMap<Integer, String> immutableMap = ImmutableMap.of(
                1, "Geeks",
                2, "For",
                3, "Geeks");
      
            // Print the ImmutableMap
            System.out.println(immutableMap);
        }
      
        public static void main(String[] args)
        {
            createImmutableMap();
        }
    }

    Producción:

    {1=Geeks, 2=For, 3=Geeks}
  3. Usando el método Java 9 Factory Of()

    En Java, use of() con Set, Map o List para crear un mapa inmutable.

    Tenga en cuenta: los programas a continuación son de Java 9. Por lo tanto, necesitaría un compilador de Java 9 para ejecutarlos.

    // Java code illustrating of() method to
    // create a ImmutableSet
    import java.util.*;
    import com.google.common.collect.ImmutableMap;
      
    class GfG {
        public static void main(String args[])
        {
            // non-empty immutable set
            Map<Integer, String> map = Map.of(
                1, "Geeks",
                2, "For",
                3, "Geeks");
      
            // Let's print the set
            System.out.println(map);
        }
    }

    Producción:

    {1=Geeks, 2=For, 3=Geeks}
  4. Usando Builder() de ImmutableMap

    En Guava, la clase ImmnutableMap proporciona una función Builder(). A través de esta función, se puede crear un nuevo ImmutableMap o se puede crear
    un ImmutableMap a partir de un mapa existente o ambos.

    • Creando un nuevo ImmutableMap

      // Java code illustrating of() method to
      // create a ImmutableSet
      import java.util.*;
      import com.google.common.collect.ImmutableMap;
        
      class GfG {
          public static void main(String args[])
          {
              // non-empty immutable set
              ImmutableMap<Integer, String> imap = 
                               ImmutableMap.<Integer, String>builder()
                                                       .put(1, "Geeks")
                                                       .put(2, "For")
                                                       .put(3, "Geeks")
                                                       .build();
        
              // Let's print the set
              System.out.println(imap);
          }
      }

      Producción:

      {1=Geeks, 2=For, 3=Geeks}
    • Creación de un mapa inmutable a partir de un mapa existente

      // Java code illustrating of() method to
      // create a ImmutableSet
      import java.util.*;
      import com.google.common.collect.ImmutableMap;
        
      class GfG {
          public static void main(String args[])
          {
              // non-empty immutable set
              Map<Integer, String> map = Map.of(1, "Geeks",
                                                2, "For",
                                                3, "Geeks");
              ImmutableMap<Integer, String> imap = 
                             ImmutableMap.<Integer, String>builder()
                                                       .putAll(map)
                                                       .build();
        
              // Let's print the set
              System.out.println(imap);
          }
      }

      Producción:

      {1=Geeks, 2=For, 3=Geeks}
    • Creando un nuevo ImmutableMap incluyendo el Mapa existente

      // Java code illustrating of() method to
      // create a ImmutableSet
      import java.util.*;
      import com.google.common.collect.ImmutableMap;
        
      class GfG {
          public static void main(String args[])
          {
              // non-empty immutable set
              Map<Integer, String> map = Map.of(1, "Geeks",
                                                2, "For",
                                                3, "Geeks");
              ImmutableMap<Integer, String> imap = 
                           ImmutableMap.<Integer, String>builder()
                                                     .putAll(map)
                                               .put(4, "Computer")
                                                 .put(5, "Portal")
                                                         .build();
        
              // Let's print the set
              System.out.println(imap);
          }
      }

      Producción:

      {1=Geeks, 2=For, 3=Geeks, 4=Computer, 5=Portal}

Intenta cambiar ImmutableMap

Como se mencionó anteriormente, el siguiente programa lanzará UnsupportedOperationException .

// Java code to show that UnsupportedOperationException
// will be thrown when ImmutableMap is modified.
import java.util.*;
  
class GfG {
    public static void main(String args[])
    {
        // empty immutable map
        Map<Integer, String> map = Map.of();
  
        // Lets try adding element in these set
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
    }
}

Producción :

Exception in thread "main" java.lang.UnsupportedOperationException
    at com.google.common.collect.ImmutableCollection.add(ImmutableCollection.java:218)
    at ImmutableListDemo.main(Main.java:16)

¿En qué se diferencia de Collections.unmodifiableMap()?

Collections.unmodifiableMap crea un contenedor alrededor del mismo mapa existente de modo que el contenedor no se puede usar para modificarlo. Sin embargo, aún podemos cambiar el mapa original.

// Java program to demonstrate that a Map created using
// Collections.unmodifiableMap() can be modified indirectly.
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
  
        // Create ImmutableMap from Map using copyOf()
        Map<Integer, String> imap = Collections.unmodifiableMap(map);
  
        // We change map and the changes reflect in imap.
        map.put(4, "Computer");
        map.put(5, "Portal");
  
        System.out.println(imap);
    }
}

Producción:

{1=Geeks, 2=For, 3=Geeks, 4=Computer, 5=Portal}

Si creamos un ImmutableMap a partir de un Mapa existente y cambiamos el Mapa existente, el ImmutableMap no cambia porque se crea una copia.

// Below is a Java program for
// Creating an immutable Map using copyOf()
// and modifying original Map.
import java.io.*;
import java.util.*;
import com.google.common.collect.ImmutableMap;
  
class GFG {
    public static void main(String[] args)
    {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
  
        // Create ImmutableMap from Map using copyOf()
        ImmutableMap<Integer, String> imap = ImmutableMap.copyOf(map);
  
        // We change map and the changes wont reflect in imap.
        map.put(4, "Computer");
        map.put(5, "Portal");
  
        System.out.println(imap);
    }
}

Producción :

{1=Geeks, 2=For, 3=Geeks}

Publicación traducida automáticamente

Artículo escrito por RishabhPrabhu y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *