Scribd
Cargar
47 vistas

Java 19

Este documento presenta una introducción al API Stream en Java. Explica cómo crear streams a partir de colecciones, arrays y rangos de enteros, y describe operadores comunes como map, filter, distinct, count y reduce para procesar y transformar los datos de los streams. También muestra cómo usar streams de enteros para sumar valores y extraer estadísticas.

Cargado por

Rocio Soriano
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
47 vistas

Java 19

Este documento presenta una introducción al API Stream en Java. Explica cómo crear streams a partir de colecciones, arrays y rangos de enteros, y describe operadores comunes como map, filter, distinct, count y reduce para procesar y transformar los datos de los streams. También muestra cómo usar streams de enteros para sumar valores y extraer estadísticas.

Cargado por

Rocio Soriano
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 28

F.4411.316.013 - POEJ/MIXTO/F.

Generation/
Curso JAVA (Online-Nacional) 3ªEd.

Java Bootcamp
Eduardo Corral Muñoz
[email protected]
Java
Intermedio 4
Índice
_01 API Stream
_02 Crear un Stream
_03 Operador map
_04 Operador filter
_05 anyMatch y allMatch
_06 count, distinct, reduce
_07 Stream de enteros
01

API Stream
API Stream
Es una combinación de lo mejor del Iterator y la programación
funcional para trabajar con flujos de datos.
Los stream son flujos o secuencias de datos que proceden en
general de una colección de Java o una matriz, sobre los que
podemos realizar operaciones, flitrarlos, …
Los elementos de un stream mantiene el mismo orden que en la
fuente.
No almacenan datos, no son contenedores, solo los “transmite”.

Manual
API Stream
Crea flujos de datos continuos.
Contienen operadores para procesar secuencias de datos.
Los operadores simplifican las transformaciones de los datos.
Transforma y compone flujos con diversos operadores como
map, filter, concat, distinct, flatmap, sorted, foreach, …
Se pueden crear desde Collections, matrices o rangos.
Son inmutables, la instancia original permanece inalterable, los
operadores devuelven una nueva instancia.
No almacenan datos, no son contenedores, solo los “transmite”.
Facilitan la concurrencia (threads, sincronización de procesos…)
Trabajan con expresiones lambda.
02

Crear un Stream
Crear un Stream
Método Stream.of(valores)

Stream<String> nombres = Stream.of("Juan","Marta","José","María");


//nombres.forEach(e -> System.out.println(e));
nombres.forEach(System.out::println);
Crear un Stream
Método Arrays.stream(arr)

String[] arr = {"Juan","Marta","José","María"};


Stream<String> nombres = Arrays.stream(arr);
nombres.forEach(System.out::println);
Crear un Stream
Método Stream builder

Stream<String> nombres = Stream.<String>builder()


.add("Juan")
.add("Marta")
.add("José")
.add("María")
.build();
nombres.forEach(System.out::println);
Crear un Stream
Desde un tipo Collection

List<String> lista = new ArrayList<>();


lista.add("Juan");
lista.add("Marta");
lista.add("José");
lista.add("María");
//Stream<String> nombre = lista.stream();
//nombres.forEach(System.out::println);
lista.stream().forEach(System.out::println);
03

Operador map
Operador map
Es un operador intermedio que nos permite modificar o convertir
los datos del flujo.
Retorna el dato modificado
Se ejecutan cuando se invoca un operador terminal.
Stream<String> nombres = Stream.of("Juan", "Marta", "José", "María")
.peek(e -> System.out.println(e)) // Inspección
.map(nombre -> nombre.toUpperCase());
//.map(String::toUpperCase);
// operadores terminales
//nombres.forEach(e -> System.out.println(e));
// convertir a lista
List<String> lista = nombres.collect(Collectors.toList());
lista.forEach(System.out::println);
Operador map
Convertir en otro tipo (objetos).
Creamos la clase Usuario
public class Usuario {
private String nombre;
private String apellidos;
… constructor
… getters y setters
}
Operador map
Creamos una nueva clase Ejemplo
Stream<Usuario> nombres = Stream.of("Juan", "Marta", "José”,”María ")
.map(nombre -> new Usuario(nombre,null))
.peek(u -> System.out.println(u.getNombre())
.map(usuario -> {
String nombre = usuario.getNombre().toUpperCase();
usuario.setNombre(nombre);
return usuario;
});
// convertir a lista
List<Usuario> lista = nombres.collect(Collectors.toList());
lista.forEach(u -> System.out.println(u.getNombre());
04

Operador filter
Operador filter
Es un operador intermedio que nos permite filtrar los datos del
flujo.

Stream<String> nombres = Stream.of("Juan", "Marta", "José", "María")


.map(nombre -> nombre.toUpperCase())
//.filter(u -> u.equals("JUAN"))
.filter(u -> u.contains("M"));

nombres.forEach(e -> System.out.println(e));


05

anyMatch y allMatch
Operadores anyMatch y allMatch
Es un operador terminal booleano que nos permite buscar
coincidencias en los datos del flujo.

boolean nombres = Stream.of("Juan", "Marta", "José Andrés", "María")


.map(nombre -> nombre.toUpperCase())
//.anyMatch(u -> u.contains(“J")) // Terminal
.allMatch(u -> u.contains(“A"));

System.out.println(nombres);
06

count, distinct, reduce


count
Es un operador terminal long que permite contar los elementos de
un stream, con o sin filtros.

long count = Stream.of("Juan", "Marta", "", "José","", "María")


.filter(n -> n.isEmpty())
.peek(e -> System.out.println(e))
.count();

System.out.println("count = " + count);


distinct
Es un operador terminal que permite eliminar los duplicados.

Stream<String> nombres = Stream.of("Juan", "Marta", "Pepe",


"José", "Pepe", "María", "Pepe")
.distinct();

nombres.forEach(System.out::println);
reduce
Es un operador terminal que permite concatenar los elementos de
un Stream.

Stream<String> nombres = Stream.of("Juan", "Marta", "Pepe",


"José","Pepe", "María")
.distinct();

String resultado = nombres.reduce("resultado concatenado


=",(a,b)-> a + ", " + b);

System.out.println(resultado);
07

Streams de enteros
reduce, sum, rangos, …
reduce y sum
Operadores terminales que permiten sumar todos los elementos
de un Stream de enteros.

Stream<Integer> numeros = Stream.of(5, 10, 15, 20, 25);

//int resultado = numeros.reduce(0,(a,b)-> a + b);


int resultado = numeros.reduce(0, Integer::sum);

System.out.println(resultado);
rangos
Operadores terminales que definir un rango de números enteros.
IntStream  Stream de enteros.

//IntStream numeros = IntStream.rangeClosed(5, 20) // 5 .. 20


IntStream numeros = IntStream.range(5, 20) // 5 .. 19
.peek(System.out::println);

//int resultado = numeros.reduce(0,(a,b)-> a + b);


//int resultado = numeros.reduce(0, Integer::sum);
int resultado = numeros.sum(); // Solo disponible en IntStream

System.out.println(resultado);
Estadisticas
Operadores terminales que permite extraer datos estadísticos de
un IntStream.
IntStream numeros = IntStream.rangeClosed(5, 20) // 5 .. 20
.peek(System.out::println);

IntSummaryStatistics estadisticas = numeros.summaryStatistics();


System.out.println("max: " + estadisticas.getMax());
System.out.println("media: " + estadisticas.getAverage());
System.out.println("min: " + estadisticas.getMin());
System.out.println("cuenta: " + estadisticas.getCount());
System.out.println("suma: " + estadisticas.getSum());
System.out.println("resumen: " + estadisticas.toString());

También podría gustarte