将这两个Java流合并为一个

是否有可能将方法中的两个流合并为一个流，因此只有一个返回语句行？该方法应计算给定二维双数组中每个列的总和，该数组的结构不重要，但该数组至少有一个元素，并且允许非空行。非常感谢

publicstaticdouble[]sumUpCols（double[]x）{
double[]]a=Stream.of（x）.已排序（（a0，a1）->a1.length-a0.length）.toArray（double[][]：：new）；
返回IntStream.range（0，a[0].length）.mapToDouble（i->IntStream.range（0，a.length）.mapToDouble（j->i

不完全是单流遍历，但更好的方法是确定嵌套数组的最大可能长度。然后使用它作为索引进行迭代，然后

public static double[] sumUpColumns(double[][] x) {
    return IntStream.range(0, Stream.of(x).mapToInt(a -> a.length).max().orElse(0))
            .mapToDouble(i -> Arrays.stream(x)
                    .mapToDouble(item -> i < item.length ? item[i] : 0.0)
                    .sum())
            .toArray();
}

publicstaticdouble[]sumUpColumns（double[]x）{
返回IntStream.range（0，Stream.of（x）.mapToInt（a->a.length）.max（）.orElse（0））
.mapToDouble（i->Arrays.stream（x）
.mapToDouble（项->i

通过将数组转换为一个映射，其中列索引是键，值是列的总和，而不对数组进行排序的盒装试验：

Collection<Double> values = Arrays.stream(x)
      .flatMap(b -> IntStream.range(0, b.length)
                    .mapToObj(i -> new AbstractMap.SimpleEntry<Integer, Double>(i, b[i])))
      .collect(groupingBy(e -> e.getKey(), summingDouble(v -> v.getValue())))
      .values();

Collection values=Arrays.stream（x）
.flatMap（b->IntStream.range（0，b.length）
.mapToObj（i->newAbstractMap.SimpleEntry（i，b[i]））
.collect（groupingBy（e->e.getKey（），summingDouble（v->v.getValue（）））
.values（）；

减小λ-不使用

map

、

flatMap

或附加

IntStream

public static double[] sumUpCols(double[][] x) {
  double[][] sum = new double[][] { {0}, {} };
  return( Stream.of( x ).reduce( (a1, a2) -> {
    for( int i = 0; i < a1.length || i < a2.length; i++ ) {
      sum[0] = Arrays.copyOf( sum[0], i + 1 );
      sum[0][i] = 0;
      try {
        sum[0][i] += a1[i];
      }
      catch( ArrayIndexOutOfBoundsException ex ) {}  // ignored
      try {
        sum[0][i] += a2[i];
      }
      catch( ArrayIndexOutOfBoundsException ex ) {}  // ignored
    }
    return sum[0];
  } ).get() );
}

publicstaticdouble[]sumUpCols（double[]x）{
double[][]和=新的double[][{{0}，{}；
返回（x的流）。减少（a1，a2）->{
对于（int i=0；i

动态放大结果数组
也可以处理空行

---

获取：

[12.0,10.0,6.0]

您是在问如何将流压缩到一起吗？Hello@AndyTurner，是的，这是正确的术语。在您尝试合并流和类似内容之前，如何修复代码，使其不会崩溃和死亡？--尝试输入

{{1}、{2,3}、{4,5,6}、{2,3}

，您会得到

ArrayIndexOutOfBoundsException:Index2超出长度2的界限

——试着输入

{{1}，{2}

，你会得到

[1.0]

，但那应该是

[3.0]

--那么，可能实际工作的不同代码已经是一个流了，谁知道呢？Hello@Andreas，很抱歉，我已经编辑并修复了代码。使用新代码，排序的目的是什么？我尝试计算列和，不是行和。此解决方案的结果与@unknown_dcba指出的问题中的结果不匹配。此外，您可以将其简化为

returnstream.of（x）.mapToDouble（（double[]行）->DoubleStream.of（row.sum（））.toArray（）谢谢！一行代码：
returnarrays.stream（x）.flatMap（b->IntStream.range（0，b.length）.mapToObj（i->new AbstractMap.SimpleEntry（i，b[i]）.collector（Collectors.groupingBy（e->e.getKey（），Collectors.summingDouble（v->v.getValue（）））.values（）.stream（）.mapToDouble（d->.d.）.toArray（）
public static double[] sumUpCols(double[][] x) {
  double[][] sum = new double[][] { {0}, {} };
  return( Stream.of( x ).reduce( (a1, a2) -> {
    for( int i = 0; i < a1.length || i < a2.length; i++ ) {
      sum[0] = Arrays.copyOf( sum[0], i + 1 );
      sum[0][i] = 0;
      try {
        sum[0][i] += a1[i];
      }
      catch( ArrayIndexOutOfBoundsException ex ) {}  // ignored
      try {
        sum[0][i] += a2[i];
      }
      catch( ArrayIndexOutOfBoundsException ex ) {}  // ignored
    }
    return sum[0];
  } ).get() );
}