文件大小的递归平均值[JAVA]

我编写了一个函数，读取所有文件并将其添加到arraylist，如下所示：

ArrayList<File> files = new ArrayList<File>();

public static Double mean(ArrayList<File> files) {
    if(files.size() == 1) {
      return Double.valueOf(files.get(0).length());
    }
    else {
      int _removed = (int) files.remove(files.size() - 1).length();
      return Double.valueOf(mean(files) + _removed / files.size());
    }
  }

ArrayList files=new ArrayList（）；

我需要计算ArrayList中所有文件的大小（字节）的算术平均值

---

考虑到这些文件很多，我决定让均值函数递归

我得到了这样的东西：

ArrayList<File> files = new ArrayList<File>();

public static Double mean(ArrayList<File> files) {
    if(files.size() == 1) {
      return Double.valueOf(files.get(0).length());
    }
    else {
      int _removed = (int) files.remove(files.size() - 1).length();
      return Double.valueOf(mean(files) + _removed / files.size());
    }
  }

公共静态双平均值（ArrayList文件）{
如果（files.size（）==1）{
返回Double.valueOf（files.get（0.length（））；
}
否则{
int_removed=（int）files.remove（files.size（）-1.length（）；
返回Double.valueOf（mean（files）+_removed/files.size（））；
}
}

---

但我做错了，因为这会导致堆栈溢出错误。如何正确编写此函数？

在这种情况下，您可能不应该使用递归。这样做会在堆栈上推送很多东西，并使其容易发生堆栈溢出错误。最好使用增强的for循环

long totalSum =0;
for(File file: files) {
     totalSum += file.length();
}  
return Double.valueOf(totalSum / files.size());

---

在这种情况下，您可能不应该使用递归。这样做会在堆栈上推送很多东西，并使其容易发生堆栈溢出错误。最好使用增强的for循环

long totalSum =0;
for(File file: files) {
     totalSum += file.length();
}  
return Double.valueOf(totalSum / files.size());

---

对于所有希望通过

流API实现每个循环的人：

double mean = files.stream().mapToLong(File::length).sum() / files.size();

感谢评论员Olivier和Johannes提供了更简单的解决方案：

OptionalDouble mean = files.stream().mapToLong(File::length).average();

对于所有希望通过
流API实现每个循环的人：

double mean = files.stream().mapToLong(File::length).sum() / files.size();

感谢评论员Olivier和Johannes提供了更简单的解决方案：

OptionalDouble mean = files.stream().mapToLong(File::length).average();

由于您正在对递归调用的返回值执行操作，因此在程序结束之前，无法解析重新调用的操作堆栈

但是，在您的情况下，使用递归调用比使用简单循环没有任何优势，尤其是在处理大型数据结构时：

public static Double mean(ArrayList<File> files) {
    Double sum = 0;
    for (File file : files) {
        sum += file.length();
    }
    return sum / files.size();
}

公共静态双平均值（ArrayList文件）{
双和=0；
用于（文件：文件）{
sum+=file.length（）；
}
返回sum/files.size（）；
}
由于您正在对递归调用的返回值执行操作，因此在程序结束之前，无法解析重新调用的操作堆栈

但是，在您的情况下，使用递归调用比使用简单循环没有任何优势，尤其是在处理大型数据结构时：

public static Double mean(ArrayList<File> files) {
    Double sum = 0;
    for (File file : files) {
        sum += file.length();
    }
    return sum / files.size();
}

公共静态双平均值（ArrayList文件）{
双和=0；
用于（文件：文件）{
sum+=file.length（）；
}
返回sum/files.size（）；
}
为什么不使用增强的for循环来遍历
ArrayList
中的所有文件？“考虑到这些文件太多，我决定让均值函数递归”必须处理线性递归函数中的“太多”任何内容，这是堆栈溢出的可靠保证。唯一需要递归的地方，从子文件夹获取文件时。要计算平均值，您只需迭代ArrayList为什么不使用增强的for循环来迭代
ArrayList
中的所有文件？“考虑到这些文件很多，我决定让均值函数递归”必须处理“很多”线性递归函数中的任何东西都有一个可靠的堆栈溢出保证。唯一需要递归的地方是从子文件夹获取文件时。要计算平均值，您只需在ArrayList上迭代，最好将
\u removed
命名为
total
或@oreh编写的
totalSum
重命名变量和长度（）返回long，因此最好使用long类型的sum或bigingerbetter来命名
\u作为
total
或
totalSum
删除，因为@oreh编写了重命名变量更好，length（）返回long，因此最好使用long类型的sum或bigingerthanks@Matt，但这不是更好吗？谢谢@Matt，但在这里不是更好吗？