Java Stream Reducción de matriz de objetos.

java-8 java-stream

Question

Tengo una lista de matriz de 2 objetos:

List<Object[2]>

Donde objeto [0] es un entero y objeto [1] es una cadena.

¿Cómo puedo transmitir la lista y aplicar diferentes funciones en cada objeto? De modo que, el resultado será una matriz que tiene:

result[0] = multiplication of all object[0]
result[1] = concatenation of all object[1]

Answer 1

Con JDK-12, puedes usar

Object[] array = list.stream()
    .collect(Collectors.teeing(
        Collectors.reducing(1, a -> (Integer)a[0], (a,b) -> a * b),
        Collectors.mapping(a -> (String)a[1], Collectors.joining()),
        (i,s) -> new Object[] { i, s}
    ));

pero realmente deberías repensar tus estructuras de datos.

Esta respuesta muestra una versión del colector de teeing que funciona bajo Java 8.

Answer 2

Puedes lograr esto con reduce() :

public void testStacko() {
    List<Object[]> list = new ArrayList<>();
    list.add(new Object[] {1, "foo"});
    list.add(new Object[] {6, "|bar"});
    list.add(new Object[] {15, "|baz"});
    Object[] array = list.stream()
                         .reduce(
                                  (obj1, obj2) -> 
                                   new Object[] {(int) obj1[0] * (int) obj2[0], 
                                                 (String) obj1[1] + (String) obj2[1]
                                                }
                                )
                         .get();
    System.out.println(array[0]); // 90
    System.out.println(array[1]); // foo|bar|baz
}

Answer 3

Ya tienes una buena respuesta técnica, así que vamos a agregar una no-respuesta distinta.

Esto aquí: List<Object[2]> siente muy mal.

¿Por qué no usa algo como: List<Pair<Integer, String>> ?

En otras palabras: no renunciar a la información de tipo a la ligera. No haga un mal uso del Object[] como un contenedor sin tipo para rellenar cosas ya escritas. Java es un lenguaje compilado estáticamente . Significado: no resistir las fuerzas de los genéricos y la escritura estricta, en lugar de eso fluye con ellos.

Y el código de respuesta se convierte en:

.reduce(p1, p2 -> new Pair<>(p1.first * p2.first, p1.second + p2.second))

En serio: comienza utilizando Object[] ... y finaliza cuando cambias a ruby ​​porque la escritura es dinámica.