Recopilación de una secuencia en una colección inmutable en Java

Streams y Collectors se introdujeron en Java 8 introdujo el concepto de Streams. Un Stream es una secuencia, una secuencia de objetos. Generamos Streams a partir de fuentes de entrada como Arrays, Lists, etc., y admitimos operaciones de agregación como filtrar, mapear, limitar, reducir, etc. Usamos Streams para canalizar datos y, en última instancia, recopilarlos en algún tipo de Recopilador. Un Collector no es más que el contenedor utilizado para almacenar el resultado del procesamiento de Stream. Un recopilador puede ser una lista, un mapa o un conjunto.

Una colección inmutable es una colección cuyos valores no podemos cambiar una vez creada. Necesitamos colecciones inmutables porque muchas veces podemos tener colecciones de datos que no cambian, es decir, listas de búsqueda. Por ejemplo, una lista de meses en un año o días de la semana, etc. Hacer tales listas (que tienen datos que no cambian) inmutables las hace más eficientes en memoria y espacio. También son inherentemente seguros para subprocesos. Los objetos inmutables, en general, requieren mucha menos memoria que sus contrapartes mutables.

Un objeto se considera inmutable si su estado no puede cambiar después de su construcción. Después de crear una instancia inmutable de una colección, contiene los mismos datos siempre que exista una referencia a ella.

Métodos: dependiendo de la versión de Java, hay varios métodos disponibles para crear objetos inmutables según el avance en las versiones de Java con las que podemos crear colecciones inmutables.

1. Pre-Java 10
   • Creando Stream y recopilándolo en una estructura no modificable usando el » recolectando y luego «
   • Biblioteca de guayaba de Google
2. Después de Java 10
   • a la lista no modificable()
   • toUnmodificableMap()
   • toUnmodificableSet()

Escenario 1: Pre-Java 10

Método 1: crear Stream y recopilarlo en una estructura no modificable. Antes de Java 10 no había una forma directa de crear una colección inmutable en Java. Un método fue crear un Stream y recopilarlo en una estructura no modificable utilizando el método » recolectar y luego «.

Ejemplo:

// Java Program to illustrate Collecting a Stream to an
// Immutable Collection
// Pre java 10
// Using collectingAndThen method
 
// Importing Collections, Collectors and Stream classes
// from java.util package
import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// Main class
// PreJava10ImmutableCollections
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Custom inputs integer elements in List
        var unmodifiableList
            = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
                  .collect(Collectors.collectingAndThen(
                      Collectors.toList(),
                      Collections::unmodifiableList));
 
        System.out.println(unmodifiableList);
 
        // Operations like this will result in an exception
        unmodifiableList.add(12);
    }
}

 Producción: 

Método 2: Usar la biblioteca Guava de Google. Para ello se requiere un trabajo previo que es incluir el archivo JAR. El JAR para la biblioteca Guava es descargar el jar y agregarlo a la ruta de compilación en eclipse. La biblioteca Guava proporciona la clase ImmutableList. Un ejemplo de lo mismo se da a continuación.

Ejemplo:

// Java Program to illustrate Collecting a
// Stream to an Immutable Collection
// Pre java 10  Using Google’s Guava library
 
// Importing Guava library
import com.google.common.collect.ImmutableList;
// Importing classes from java.util package
import java.util.List;
import java.util.stream.IntStream;
 
// Main class
public class PreJava10ImmutableCollections {
 
    // main driver method
    public static void main(String[] args) {
 
        // Using the Guava Libraries
        List<Integer> someList
            = IntStream.range(0, 15).boxed().collect(
                  ImmutableList.toImmutableList());
 
        // Print and display the elements
        System.out.println(someList);
    }
}

Producción: 

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Nota: También podemos implementar nuestra propia versión de hacer una lista, mapa o conjunto inmutable.

Escenario 2: Java versión 10 y superior

La versión 10 de Java introdujo funciones para crear colecciones inmutables a través de la clase Collectors. Tenemos 3 métodos, uno para Lista, uno para Conjunto y otro para Mapa. 

Método 1: Usar el método toUnmodifiableList() . Supongamos que tenemos un flujo de los primeros 50 números pares y creamos una lista inmutable a partir de él.

Ejemplo: 

// Java Program to illustrate Collecting a Stream to
// an Immutable Collection
// Post java 10
// using toUnmodifiableList() method
 
// Importing classes from java.util package
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// Main Class
// ImmutableCollectionList
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating Stream class object of integer type
        Stream<Integer> evenNumberStream
            = Stream.iterate(0, i -> i + 2).limit(50);
 
        // Creating List class object of integer type
        List<Integer> evenNumbers
            = (List<Integer>)evenNumberStream.collect(
                Collectors.toUnmodifiableList());
 
        // Print all elements in the List object
        System.out.println(evenNumbers);
 
        // These will result in
        // java.lang.UnsupportedOperationException
 
        evenNumbers.add(90);
        // evenNumbers.remove(1);
    }
}

Producción: 

Método 2: Uso del método toUnmodifiableMap() 

Considere un ejemplo de una clase de Libros. El objeto Books tiene dos parámetros, a saber, ‘Id’ y ‘Name’. Generaremos un flujo de objetos de libros. Supongamos que tenemos que generar un Mapa inmutable a partir de esta colección de Objetos. Para hacerlo, usamos la función toUnmodifiableMap().

Ejemplo: 

// Java Program to illustrate Collecting a Stream to
// an Immutable Collection
// Post java 10
// Using toUnmodifiableMap() method
 
// Importing required libraries
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// Main Class
// ImmutableCollectionMap
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating a Map from a Stream of books by
        // creating an object of List class of books type
        List<Books> libInventory = new ArrayList<Books>();
 
        // Adding elements to the above object created
        // Custom input entries
        libInventory.add(
            new Books(1, "Pride and Prejudice"));
        libInventory.add(new Books(2, "The Sign of Four"));
        libInventory.add(
            new Books(3, "Sense and Sensibility"));
        libInventory.add(new Books(4, "Mansfield Park"));
        libInventory.add(
            new Books(5, "The Materese Circle"));
        libInventory.add(
            new Books(6, "The Hound of Baskerville"));
        libInventory.add(new Books(7, "Goodnight Moon"));
        libInventory.add(new Books(
            8, "How many sleeps till my Birthday"));
        libInventory.add(
            new Books(9, "The Bourne Identity"));
        libInventory.add(new Books(10, "Murder She Wrote"));
        libInventory.add(new Books(
            11, "The adventures of Hercule Poirot"));
        libInventory.add(
            new Books(12, "The song of Ice and Fire"));
 
        // Creating a Map class object
        // Declaring object of integer and string type
        Map<Integer, String> unmutableInventory
            = libInventory.stream().collect(
                Collectors.toUnmodifiableMap(
                    Books::getBookNumber,
                    Books::getBookName));
 
        // Print all the elements in the Map object created
        // above
        System.out.println(unmutableInventory);
 
        // This will result in an Exception
        unmutableInventory.put(13, "Some book");
    }
}

Producción:

Método 3: Usar el método toUnmodifiableSet() 

Implementación: crear un conjunto no modificable a partir de una secuencia para hacerlo, usamos la función toUnmodifiableSet(). 

// Java Program to illustrate Collecting a Stream to
// an Immutable Collection
// Post java 10
// Using toUnmodifiableSet() method
 
// Importing required libraries
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// Main class
// ImmutableCollectionSet
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating Stream object of type Double
        Stream<Double> randomDecimals
            = Stream.generate(Math::random).limit(30);
 
        // Now creating Set class object of type Double
        Set<Double> randomSet = randomDecimals.collect(
            Collectors.toUnmodifiableSet());
 
        // Print and display elements in Set object
        System.out.println(randomSet);
 
        // This will produce an exception
        randomSet.add(100.0);
    }
}

 Conclusión: Aquí hemos visto cómo crear Colecciones Inmutables a partir de un Stream en Java. También vimos los diferentes métodos utilizados para crear las Colecciones en función de la versión de Java utilizada.