😹 🏬 😝 Nuevo en Java 12: The Teeing Collector 🍉 😥 📹

En este artículo, veremos un nuevo recopilador introducido en Java 12. Esta nueva función no se anunció en el JEP oficial, ya que era una solicitud de cambio menor con el título " Crear recopilador, que combina los resultados de otros dos recopiladores ". Está diseñado para combinar resultados de dos recolectores.

Todo interesante - debajo del corte

Si aún no sabes qué son los coleccionistas

Los recopiladores son clases especiales que se utilizan para convertir una secuencia en otra estructura de datos. Por ejemplo, en la list :

 list = Stream.of(1,2,3).collect(Collectors.toList()); //     1, 2  3

Este es un ejemplo inútil, porque crea una nueva secuencia e inmediatamente la transforma. Está pensado para mostrar el uso de coleccionistas

La documentación

Haga clic aquí para ver Collectors#teeing . Según la documentación oficial:

“... devuelve un colector compuesto por dos colectores subordinados. Cada elemento transferido al colector resultante es procesado por ambos colectores subordinados, y luego sus resultados se combinan utilizando una función especial que los conecta con el resultado final ".
El original
"... devuelve un recopilador que es un compuesto de dos recopiladores posteriores. Cada elemento pasado al recopilador resultante es procesado por ambos recopiladores posteriores, luego sus resultados se combinan utilizando la función de combinación especificada en el resultado final".

Encabezado del método:

 static <T, R1, R2, R> Collector<T, ?, R> teeing( Collector<? super T, ?, R1> downstream1, Collector<? super T, ?, R2> downstream2, BiFunction<? super R1, ? super R2, R> merger)

Hecho interesante

Esta es una camiseta ( tee del inglés):

Teeing vino de un tee. Según Wikipedia, "una conexión en T es la conexión más común (parte de conexión de una tubería, traductor aprox.) Utilizada para combinar [o dividir] una corriente de fluido (en este caso, nos referimos a corrientes, corriente - corriente / corriente, traductor de comentarios)".

Se propusieron otros nombres: biseccionar (dividir en 2 partes), duplexar, bifurcar (dividir), replicador, abanico (dividir), tocar, descomprimir, colecciónToBothAndThen, biCollecting, expandir (extensión), bifurcación, etc.
Todas las alternativas calificadas por los desarrolladores principales se pueden encontrar aquí .

Ejemplos de uso

He compilado tres ejemplos de uso de código con diferentes niveles de complejidad.

Lista de invitados

Extraemos dos tipos diferentes de información de la lista de objetos en la secuencia. Cada invitado debe aceptar la invitación y puede dirigir a la familia. Queremos saber quién confirmó la reserva y el número total de participantes (incluidos invitados y miembros de la familia).

 var result = Stream.of( // Guest(String name, boolean participating, Integer participantsNumber) new Guest("Marco", true, 3), new Guest("David", false, 2), new Guest("Roger",true, 6)) .collect(Collectors.teeing( //  ,    ,    Collectors.filtering(Guest::isParticipating, //        Collectors.mapping(o -> o.name, Collectors.toList())), //  ,       Collectors.summingInt(Guest::getParticipantsNumber), //      , //    EventParticipation::new )); System.out.println(result); //  // EventParticipation { guests = [Marco, Roger], // total number of participants = 11 }

Invitado

 class Guest { private String name; private boolean participating; private Integer participantsNumber; public Guest(String name, boolean participating, Integer participantsNumber) { this.name = name; this.participating = participating; this.participantsNumber = participantsNumber; } public boolean isParticipating() { return participating; } public Integer getParticipantsNumber() { return participantsNumber; } }

Participacion del evento

 class EventParticipation { private List<String> guestNameList; private Integer totalNumberOfParticipants; public EventParticipation(List<String> guestNameList, Integer totalNumberOfParticipants) { this.guestNameList = guestNameList; this.totalNumberOfParticipants = totalNumberOfParticipants; } @Override public String toString() { return "EventParticipation { " + "guests = " + guestNameList + ", total number of participants = " + totalNumberOfParticipants + " }"; }}

Filtrar nombres en dos listas diferentes

En este ejemplo, dividimos la secuencia de nombres en dos listas según el filtro.

 var result = Stream.of("Devoxx", "Voxxed Days", "Code One", "Basel One", "Angular Connect") .collect(Collectors.teeing( //   Collectors.filtering(n -> n.contains("xx"), Collectors.toList()), //   Collectors.filtering(n -> n.endsWith("One"), Collectors.toList()), //  -       (List<String> list1, List<String> list2) -> List.of(list1, list2) )); System.out.println(result); // -> [[Devoxx, Voxxed Days], [Code One, Basel One]]

Cuenta y agrega un flujo de números

Es posible que haya visto un ejemplo similar en blogs que combinan la suma y el recuento para obtener el promedio. Este ejemplo no requiere Teeing , y simplemente puede usar AverageInt y un simple recopilador.

El siguiente ejemplo utiliza funciones de Teeing para devolver dos valores:

 var result = Stream.of(5, 12, 19, 21) .collect(Collectors.teeing( //   Collectors.counting(), //   Collectors.summingInt(n -> Integer.valueOf(n.toString())), // : (count, sum) -> new Result(count, sum); Result::new )); System.out.println(result); // -> {count=4, sum=57}

Resultado

 class Result { private Long count; private Integer sum; public Result(Long count, Integer sum) { this.count = count; this.sum = sum; } @Override public String toString() { return "{" + "count=" + count + ", sum=" + sum + '}'; }}

Posible trampa

Map.Entry

Muchos ejemplos usan Map.Entry para almacenar el resultado de una BiFunction . No haga esto porque no puede almacenar el último argumento en Map . No hay ningún objeto estándar en Java Core para almacenar dos valores: deberá crearlo usted mismo.

Todo sobre las nuevas características de Java 12

Puede encontrar más información y datos interesantes sobre Java 12 en esta presentación .

¡Coleccionables exitosos!

Nuevo en Java 12: The Teeing Collector