Суммировать базовые элементы случайно вложенного массива в Java?

Question

Учитывая многомерный массив целых чисел, как я могу найти сумму всех базовых элементов?В каждом массиве может быть разное количество массивов, поэтому мой алгоритм должен быть гибким, чтобы вместить все возможные входные данные.Рекурсивный метод представляется наиболее элегантным решением.Пример:

Дано:

array = {
   {{1,2,3},
   {4,5},
   {6,7,8}},
   {{9},{10}}
}

Возврат : 55

Обратите внимание, что длина каждого подпунктаМассив является непоследовательным и изменяется, а также глубина массива.Это означает, что традиционные циклы не смогут проверить длину массива, а рекурсивные методы не смогут определить количество измерений, которые цикл имеет в качестве исходного параметра.Возможно, рекурсивный цикл должен был бы привести Object к массиву?

---

Редактировать:

Метод также должен иметь возможность суммировать массивЛЮБОЕ количество измерений.Например, входной массив может иметь три измерения или даже 7.

Answer 1

Используя Java Streams, вы можете использовать только это (при условии, что ваш массив имеет 2 измерения):

int[][] array = {{1, 2, 3}, {4, 5}, {6, 7, 8}, {9, 10}};
int sum = Arrays.stream(array)
        .flatMapToInt(Arrays::stream)
        .sum();

Если ваш массив имеет 3 измерения, вы можете расширить его до следующего:

int[][][] array = {{{1, 2, 3}, {4, 5}, {6, 7, 8}}, {{9}, {10}}};
int sum = Arrays.stream(array)
        .flatMap(Arrays::stream)
        .flatMapToInt(Arrays::stream)
        .sum();

Для обработки массивов с неизвестной глубиной вы можете использовать этот метод для их выравнивания:

private static Stream<Object> flatMapDynamicArray(Object[] array) {
    return Arrays.stream(array)
            .flatMap(o -> o.getClass().isArray() ? 
                    flatMapDynamicArray((Object[]) o) : 
                    Stream.of(o));
}

Вы также можете использовать o instanceof Object[] вместо o.getClass().isArray(), но для моих тестов второй показал лучшую производительность.

Используйте этот метод следующим образом:

Integer[][][] array = {{{1, 2, 3}, {4, 5}, {6, 7, 8}}, {{9}, {10}}};
int sum = flatMapDynamicArray(array)
        .mapToInt(i -> (int) i)
        .sum();

Результатом во всех случаях будет 55 для массива, которым вы поделились.

Answer 2

Другая возможность, которая не использует потоки или лямбда-выражения, - это написать простой рекурсивный метод. Как и другие такого рода, конфликты типов проявляются только во время выполнения.

Для следующей структуры вложенного массива:

      Integer[][][][] array = { { { { 1, 2, 3
            }, { 4, 5, 6
            }, { 7, 8, 9
            }
            }, { { 10, 11, 12,
            }, { 13, 14, 15
            }, { 16, 17, 19
            }
            }
            }, { { { 20, 21, 22
            }, { 23, 24, 25
            }
            }
            }
      };

   System.out.println(sum(array));

   public static int sum(Object[] a) {
      int sum = 0;
      for (Object o : a) {
         if (o instanceof Object[]) {
            sum += sum((Object[]) o);
         }
         if (o instanceof Integer) {
            sum += (Integer) o;
         }
      }
      return sum;
   }

Печать

307