将数组分成子数组java 8

我有一个类似于1,2,3,4的数组 需要分成

int [] array = { 1, 2, 3 , 4}

for( int i= 0; i < array .length-0; i ++) {
  Integer[] intArrays = array .stream().toArray(Integer[]::new);
 //processing with stream
}


123, 234,34,4
sum of the each grouping 
1+2+3 =6
2+3+4 = 9
3+4 = 7
4=4

我可以用java传统的方式来实现，但需要使用Java8流概念来实现

---

你能帮我做到这一点吗？

我假设请求是将每个分组限制为3个元素。如果是,

List<Integer> l = Arrays.asList(1, 2, 3, 4);

for (int i = 0; i < l.size(); i++) {
  l.set(i, l.stream().skip(i).limit(3).mapToInt(Integer::intValue).sum());
}

---

如果您真的希望得到以下结果，这可能会变得有点复杂：

1+2+3 =6
2+3+4 = 9
3+4 = 7
4=4

在这种情况下，您可以按如下方式执行：

String result = IntStream.range(0, array.length)
                .mapToObj(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).toArray())
                .map(a -> String.join("+",
                        Arrays.stream(a).mapToObj(String::valueOf).toArray(String[]::new)) + "=" +
                        Arrays.stream(a).sum())
                .collect(Collectors.joining("\n"));
System.out.println(result);
    

IntStream.range(0, array.length)
         .mapToObj(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).toArray())
         .map(a -> String.join("+",
                    Arrays.stream(a).mapToObj(String::valueOf).toArray(String[]::new)) + "=" +
                    Arrays.stream(a).sum())
         .forEachOrdered(System.out::println);

IntStream.range(0, array.length)
         .map(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).sum())
         .forEachOrdered(System.out::println);

或如下：

String result = IntStream.range(0, array.length)
                .mapToObj(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).toArray())
                .map(a -> String.join("+",
                        Arrays.stream(a).mapToObj(String::valueOf).toArray(String[]::new)) + "=" +
                        Arrays.stream(a).sum())
                .collect(Collectors.joining("\n"));
System.out.println(result);
    

IntStream.range(0, array.length)
         .mapToObj(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).toArray())
         .map(a -> String.join("+",
                    Arrays.stream(a).mapToObj(String::valueOf).toArray(String[]::new)) + "=" +
                    Arrays.stream(a).sum())
         .forEachOrdered(System.out::println);

IntStream.range(0, array.length)
         .map(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).sum())
         .forEachOrdered(System.out::println);

但是，如果预期结果可以像打印每个组总和的结果一样简单，则可以按如下方式进行：

String result = IntStream.range(0, array.length)
                .mapToObj(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).toArray())
                .map(a -> String.join("+",
                        Arrays.stream(a).mapToObj(String::valueOf).toArray(String[]::new)) + "=" +
                        Arrays.stream(a).sum())
                .collect(Collectors.joining("\n"));
System.out.println(result);
    

IntStream.range(0, array.length)
         .mapToObj(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).toArray())
         .map(a -> String.join("+",
                    Arrays.stream(a).mapToObj(String::valueOf).toArray(String[]::new)) + "=" +
                    Arrays.stream(a).sum())
         .forEachOrdered(System.out::println);

IntStream.range(0, array.length)
         .map(i -> Arrays.stream(array).skip(i).limit(Math.min(3, array.length-i)).sum())
         .forEachOrdered(System.out::println);

说明：

第一个代码段用于生成源数组的索引，然后在操作中跳过必要数量的元素，只保留必要数量的元素。然后使用map，我们将每个组中的元素连接起来，并计算它们的总和，然后以我们想要的格式获取它们，最后，我们将字符串与收集器连接起来

第二个代码段执行相同的操作，但不是将字符串与收集器连接，而是将它们打印到控制台

---

最后一种方法在映射方面做了类似的事情，但只关注每个组求和的结果。

分组没有意义。第一个应该是1+2+3+4吗？为什么最后一组是4+4？也许只有4个？对不起，如果你能做到这一点，那就足够了me@Kasunshan为什么第一个123不应该是1234？@Kasunshan IntStream.range0，list.size.mapi->list.stream.skipi.limitMath.min3，list.size-i.mapToIntInteger:：intValue.sum.forEachOrderedSystem.out:：println。或者您可以执行IntStream.range0，l.size.forEachOrderedi->l.seti，l.stream.skipi.limit3.maptointeger:：intValue.sum；如果要避免外部迭代，可以使用Arrays.streamarray，i，Math.mini+3，array.length代替链式跳过和限制，但当唯一链式操作是toArray时，可以首先使用Arrays.copyOfRangearray，i，Math.mini+3，array.length。我不会使用toArray，只是在有CollectCollector时调用String.join。join…；此收集器还可以与第二个流操作结合使用：.mapa->Arrays.streama.mapToObjString:：valueOf.collectCollectors.joining+，=+Arrays.streama.sum