Java 8 – Ejemplos de Stream.map ()

Introducción

Una secuencia es una secuencia de objetos que admite muchos métodos diferentes que se pueden combinar para producir el resultado deseado.

Se pueden crear a partir de numerosas fuentes de datos, que suelen ser colecciones, pero también pueden ser canales de E / S, Arrays, tipos de datos primitivos, etc.

Es importante enfatizar que una corriente no es una estructura de datos, ya que no almacena ningún dato. Es solo un contenedor de fuente de datos que nos permite operar con datos más rápido, más fácil y con un código más limpio.

Una secuencia tampoco modifica nunca la estructura de datos original, solo devuelve el resultado de los métodos canalizados.

Tipos de corrientes

Las transmisiones pueden ser secuenciales (creadas con stream()), o paralelo (creado con parallelStream()). Las transmisiones paralelas pueden operar en múltiples subprocesos, mientras que las secuencias secuenciales no.

Las operaciones en los arroyos pueden ser intermedias o terminales:

Intermedio las operaciones en las corrientes devuelven una corriente. Es por eso que podemos encadenar múltiples operaciones intermedias sin usar punto y coma. Las operaciones intermedias incluyen los siguientes métodos:

• map(op) – Devuelve una nueva secuencia en la que se proporciona op La función se aplica a cada uno de los elementos del flujo original.
• filter(cond) – Devuelve una nueva secuencia que solo contiene los elementos de la secuencia original que cumplen la condición cond, especificado por un predicado
• sorted() – Devuelve la secuencia original, pero con los elementos ordenados

Terminal las operaciones son nulas o devuelven un resultado que no es de flujo. Se llaman terminales porque no podemos encadenar más operaciones de transmisión una vez que hemos usado una terminal, sin crear una nueva transmisión a partir de ella y comenzar de nuevo.

Algunas de las operaciones de la terminal son:

• collect() – Devuelve el resultado de las operaciones intermedias realizadas en la secuencia original.
• forEach() – Un método vacío que se utiliza para recorrer la secuencia.
• reduce() – Devuelve un único resultado producido a partir de una secuencia completa de elementos en la secuencia original.

En este tutorial, repasaremos map() operación y cómo podemos usarlo con Streams para convertir / mapear objetos de varios tipos.

Ejemplos de Stream.map ()

Echemos un vistazo a un par de ejemplos y veamos qué podemos hacer con el map() operación.

Flujo de enteros a flujo de cadenas

Arrays.asList(1, 2, 3, 4).stream()
        .map(n -> "Number " + String.valueOf(n))
        .forEach(n -> System.out.println(n + " as a " + n.getClass().getName()));

Aquí, hicimos una lista de enteros y llamamos stream() en la lista para crear un nuevo flujo de datos. Luego, mapeamos cada número n en la lista, a través del map() método, a una cadena. Las Strings simplemente consisten en "Number" y el String.valueOf(n).

Entonces, para cada número en nuestra lista original, ahora tendremos un "Number n" Cadena que le corresponde.

Ya que map() devuelve un Stream de nuevo, hemos utilizado el forEach() método para imprimir cada elemento en él.

Ejecutar este código da como resultado:

Number 1 as a java.lang.String
Number 2 as a java.lang.String
Number 3 as a java.lang.String
Number 4 as a java.lang.String

Nota: Esto no ha alterado la lista original en lo más mínimo. Simplemente procesamos los datos e imprimimos los resultados. Si quisiéramos persistir en este cambio, haríamos collect() los datos de nuevo en un Collection objeto como un List, Map, Set, etc:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
		
List<String> mappedList = list.stream()
        .map(n -> "Number " + String.valueOf(n))
        .collect(Collectors.toList());

System.out.println(list);
System.out.println(mappedList);

Esto resulta en:

[1, 2, 3, 4]
[Number 1, Number 2, Number 3, Number 4]

Flujo de cadenas en flujo de enteros

Ahora, hagámoslo al revés: convierta un flujo de cadenas en un flujo de enteros:

Arrays.asList("1", "2", "3", "4").stream()
        .map(n -> Integer.parseInt(n))
        .forEach(n -> System.out.println(n));

Como se esperaba, este código producirá el siguiente resultado:

1
2
3
4

Lista de objetos en la lista de otros objetos

Digamos que tenemos una clase Point que representa un punto en un sistema de coordenadas cartesiano:

public class Point {
    int X;
    int Y;
    
    Point(int x, int y){
        this.X=x;
        this.Y=y;
    }
    
    @Override
    public String toString() {
        return "(" + this.X + ", " + this.Y + ")";
    }
    
}

Entonces, digamos que queremos escalar una forma determinada por un factor de 2, esto significa que tenemos que tomar todos los puntos que tenemos y duplicar sus X y Y valores. Esto se puede hacer mapeando los valores originales con sus contrapartes escaladas.

Luego, dado que nos gustaría usar las nuevas coordenadas, recopilaremos estos datos en una nueva lista de puntos escalados:

List<Point> originalPoints = Arrays.asList(new Point(1, 2),
                                           new Point(3, 4),
                                           new Point(5, 6),
                                           new Point(7, 8));
System.out.println("Original vertices: " + originalPoints);
    
List<Point> scaledPoints = originalPoints
        .stream()
        .map(n -> new Point(n.X * 2, n.Y * 2))
        .collect(Collectors.toList());

System.out.println("Scaled vertices: " + scaledPoints);

Este ejemplo producirá el siguiente resultado:

Original vertices: [(1, 2), (3, 4), (5, 6), (7, 8)]
Scaled vertices: [(2, 4), (6, 8), (10, 12), (14, 16)]

Conclusión

En este artículo, explicamos qué transmisiones hay en Java. Mencionamos algunos de los métodos básicos utilizados en las transmisiones y nos centramos específicamente en la map() método y cómo se puede utilizar para la manipulación de flujos.

Es importante mencionar que los streams no son realmente una parte obligatoria de la programación, sin embargo, son más expresivos y pueden mejorar significativamente la legibilidad de su código, razón por la cual se convirtieron en una práctica de programación común.