Question

给定一个多维整数数组，如何找到所有基本元素的总和？每个数组中可能有不同数量的数组，因此我的算法必须灵活以容纳所有可能的输入。递归方法似乎是最优雅的解决方案。示例：

给出：

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

返回： 55

请注意，每个子阵列的长度均不一致，且各不相同，并且阵列的深度也不同。这意味着传统的循环将无法检查数组的长度，而递归方法将无法将循环具有的维数定义为初始参数。也许递归循环需要将Object转换为数组？

编辑：

该方法还应该能够对任意数量维的数组求和。例如，输入数组可以具有3个维度，甚至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

不使用流或lambda的另一种可能性是编写一种简单的递归方法。就像其他这种性质的一样，类型冲突只会在运行时出现。

对于以下嵌套数组结构：

      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

求和Java中随机嵌套数组的基本元素？

2 个答案: