Java 如何递归地添加随机数组的数字？

给定数组

static int[] testArray = {8, -5, 22, 17, 4, 9, -12, 15, 23, 25};'

如何递归地将所有值相加。我已经尝试了下面的代码，当然不起作用。这是应该的，也不是很合乎逻辑，因为我不知道如何称呼它

static int[] testArray = {8, -5, 22, 17, 4, 9, -12, 15, 23, 25};

static int i = 0;
public static void reverse(int sum) {
    i = i+1;
    int sumNum = sum;

    //if ((n/10) != 0) {
    sumNum = sumNum + testArray[i];
    reverse(sum);
    //}
}

我们将索引作为参数传递给函数。每次调用时，我们发送当前索引的值+1。当我们到达终点时，返回0（基本情况）。结果将添加到当前元素并返回

初始调用为

sumRecursive（0）

如果原始数组不是静态的，那么还必须将数组作为参数传递

我们将索引作为参数传递给函数。每次调用时，我们发送当前索引的值+1。当我们到达终点时，返回0（基本情况）。结果将添加到当前元素并返回

初始调用为

sumRecursive（0）

---

如果原始数组不是静态的，那么也必须将数组作为参数传递。

如果确实需要递归求解，可以让递归方法（我们称之为sumRecursive（array））有一个包含数组其余部分的参数

如果您有一个数组：[1,2,3,4]。调用

sumRecursive（[1,2,3,4]）

它使用

sumRecursive（[2,3,4]）

调用sum，返回值是

array[0]+*数组的其余部分*

---

---

但是，我真的不建议简单的求和是递归的，它效率低而且更复杂

如果你真的需要递归求解，你可以做的一件事是让递归方法（我们称之为sumRecursive（array））有一个包含数组其余部分的参数

如果您有一个数组：[1,2,3,4]。调用

sumRecursive（[1,2,3,4]）

它使用

sumRecursive（[2,3,4]）

调用sum，返回值是

array[0]+*数组的其余部分*

---

---

然而，我真的不建议简单的求和是递归的，它效率低而且更复杂，更像是一个附录，因为这可能是一些家庭作业，而且你已经得到了直截了当的答案（通过将索引传递给递归方法）

当然，这里真正的乐趣在于思考功能

意思是：您传递的不是完整数组或“全局”数组中的索引，而是“列表”。然后将结果折叠在一起，如所述

长话短说：非平凡解决方案的作用如下：

int sum(List<Integer> values) {
  if (values.size) == 0 return 0;
  return values.get(0) + sum(values.subList(1, values.size());

public static int recursiveSum(int[] array, int index, int sum) {
    return index == array.length ? sum : recursiveSum(array, index + 1, sum + array[index]);
}

int和（列表值）{
如果（values.size）==0，则返回0；
返回值.get（0）+sum（values.subList（1，values.size（））；

---

当然，Java并不真正适合这种编程，因为创建这些子列表并不完全适合这个简单的问题。

更多的是附录，因为这可能是一些家庭作业，您已经得到了直截了当的答案（通过向递归方法传递索引）

当然，这里真正的乐趣在于思考功能

意思是：您不需要围绕整个数组或“全局”数组中的索引，而是围绕“列表”进行传递。然后，将结果折叠在一起，如所述

长话短说：非平凡解决方案的作用如下：

int sum(List<Integer> values) {
  if (values.size) == 0 return 0;
  return values.get(0) + sum(values.subList(1, values.size());

public static int recursiveSum(int[] array, int index, int sum) {
    return index == array.length ? sum : recursiveSum(array, index + 1, sum + array[index]);
}

int和（列表值）{
如果（values.size）==0，则返回0；
返回值.get（0）+sum（values.subList（1，values.size（））；

---

当然，Java并不真正适合这种编程，因为创建这些子列表并不完全适合这个简单的问题。

为什么我们要递归地这样做？如果没有递归的好理由，那么保持简单，下面的一行将对数组求和：

Arrays.stream(testArray).sum();

但是，如果这是一些测试任务，迫使您使用递归，那么我想已经提供的其他答案是最好的选择，例如：

int sum(List<Integer> values) {
  if (values.size) == 0 return 0;
  return values.get(0) + sum(values.subList(1, values.size());

public static int recursiveSum(int[] array, int index, int sum) {
    return index == array.length ? sum : recursiveSum(array, index + 1, sum + array[index]);
}

加上一个主方法，如下所示：

static int[] testArray = { 8, -5, 22, 17, 4, 9, -12, 15, 23, 25 };

public static void main(String[] args) {
    System.out.println(Arrays.stream(testArray).sum());
    System.out.println(recursiveSum(testArray, 0, 0));
}

public static int recursiveSum(int[] array, int index, int sum) {
    return index == array.length ? sum : recursiveSum(array, index + 1, sum + array[index]);
}

---

为什么我们要递归地执行此操作？如果没有递归的好理由，那么请保持简单，下面的一行将对数组求和：

Arrays.stream(testArray).sum();

但是，如果这是一些测试任务，迫使您使用递归，那么我想已经提供的其他答案是最好的选择，例如：

int sum(List<Integer> values) {
  if (values.size) == 0 return 0;
  return values.get(0) + sum(values.subList(1, values.size());

public static int recursiveSum(int[] array, int index, int sum) {
    return index == array.length ? sum : recursiveSum(array, index + 1, sum + array[index]);
}

加上一个主方法，如下所示：

static int[] testArray = { 8, -5, 22, 17, 4, 9, -12, 15, 23, 25 };

public static void main(String[] args) {
    System.out.println(Arrays.stream(testArray).sum());
    System.out.println(recursiveSum(testArray, 0, 0));
}

public static int recursiveSum(int[] array, int index, int sum) {
    return index == array.length ? sum : recursiveSum(array, index + 1, sum + array[index]);
}

公共类递归{
静态int[]testArray={8，-5,22,17,4,9，-12,15,23,25}；
静态int i=0；
静态int sumNum=0；
公共静态整数反转（整数和）{
i++；
sumNum=sumNum+sum；
如果（i

}

公共类递归{
静态int[]testArray={8，-5,22,17,4,9，-12,15,23,25}；
静态int i=0；
静态int sumNum=0；
公共静态整数反转（整数和）{
i++；
sumNum=sumNum+sum；
如果（i

---

}

为什么一个应该添加数字的方法叫做

reverse

？这看起来真的很奇怪。为什么要通过递归来实现它？一个简单的循环更容易实现，也更有效。为什么要递归？这是必须的吗？数组的和是它的第一个元素和数组其余元素的和。为什么是一个应该添加数字的方法，名为

reverse

？这看起来很奇怪。为什么要通过递归来实现它？一个简单的循环更容易实现，也更有效。为什么要递归？这是必须的吗？数组的和是它的第一个元素和数组其余元素的和。但这是