Java Stream Уменьшение массива объектов

Question

У меня есть список массивов из 2 объектов:

List<Object[2]>

Где объект [0] - это целое число, а объект [1] - это строка.

Как мне выполнить потоковую передачуперечислить и применить различные функции для каждого объекта?Таким образом, результатом будет массив, имеющий:

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

Answer 1

Вы можете достичь этого с помощью 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 2

С JDK-12 вы можете использовать

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}
    ));

но вы действительно должны переосмыслить свои структуры данных.

В этом ответе показана версия teeing сборщика, который работает под Java 8.

Answer 3

У вас уже есть хороший технический ответ, поэтому давайте добавим четкий не ответ.

Это здесь: List<Object[2]> чувствует себя оооочень неправильно.

Почему бы вам не использовать что-то вроде: List<Pair<Integer, String>>?!

Другими словами: не отказывайтесь от информации о типах слегка. Не используйте Object[] как контейнер для несимметрии для заполнения уже набранных вещей. Java - это статически скомпилированный язык . Значение: не сопротивляйся силам дженериков и строгой типизации, вместо этого следуй им.

И код ответа превращается в:

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

Серьезно: он начинается с использования Object[] ... и заканчивается тем, что вы переключаетесь на ruby, потому что динамическая типизация!