使用java求1+2!+3!+…+20!的和完整示例代码

使用Ja va解决求1+2!+3!+...+20!的和

在编程实践中，阶乘计算算得上是个经典入门题了。简单说，n! 就是所有小于等于 n 的正整数乘起来：5! = 5×4×3×2×1 = 120。这次我们要用 Ja va 算一个稍微复杂点的东西——从1到20的阶乘求和，也就是 1 + 2! + 3! + ... + 20!。别小看这个题目，它背后涉及循环、函数封装、类型选择，甚至还能引出一点性能优化的思路。

1. 阶乘的基本概念

阶乘在组合数学、概率统计里出现频率极高。实现方式无非两种：循环或递归。不过对于20!这样的规模，递归虽然可以工作，但到了更大的数就容易引发栈溢出——所以实战中更推荐循环。下面我们就直接从代码开干。

2. Ja va代码实现

2.1 计算单个数的阶乘

先写一个辅助方法，专门算单个数的阶乘。这里用最直观的循环：

public class FactorialSum {
    // 计算单个数的阶乘
    public static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        long result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }
}

2.2 计算1到20的阶乘之和

有了factorial方法，求和就简单了：循环1到20，每次累加阶乘结果。

public class FactorialSum {
    // 计算单个数的阶乘
    public static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        long result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    // 计算1到20的阶乘之和
    public static long sumOfFactorials() {
        long sum = 0;
        for (int i = 1; i <= 20; i++) {
            sum += factorial(i);
        }
        return sum;
    }

    public static void main(String[] args) {
        long result = sumOfFactorials();
        System.out.println("1 + 2! + 3! + ... + 20! 的和为: " + result);
    }
}

2.3 运行结果

直接跑一下，输出如下：

1 + 2! + 3! + ... + 20! 的和为: 2561327494111820313

3. 性能优化

上面的代码逻辑没问题，但每次都重新计算一遍阶乘，有点浪费。实际上，后一个阶乘可以基于前一个来算：n! = n × (n-1)!。这样一来，只需要一个循环，边乘边累加，性能提升不少。代码也简洁：

public class FactorialSumOptimized {
    // 计算1到20的阶乘之和（优化版）
    public static long sumOfFactorialsOptimized() {
        long sum = 0;
        long factorial = 1;
        for (int i = 1; i <= 20; i++) {
            factorial *= i;
            sum += factorial;
        }
        return sum;
    }

    public static void main(String[] args) {
        long result = sumOfFactorialsOptimized();
        System.out.println("1 + 2! + 3! + ... + 20! 的和为: " + result);
    }
}

3.1 运行结果

结果和之前一模一样：

1 + 2! + 3! + ... + 20! 的和为: 2561327494111820313

下面是一个完整的程序示例，直接可以运行，功能和上面相同：

public class FactorialSum {
    public static void main(String[] args) {
        long sum = 0; // 用于存储最终的和
        for (int i = 1; i <= 20; i++) {
            sum += factorial(i); // 计算每个数的阶乘，并累加到sum中
        }
        System.out.println("The sum of 1 + 2! + 3! + ... + 20! is: " + sum);
    }

    /**
     * 计算n的阶乘
     * @param n 需要计算阶乘的数
     * @return n的阶乘
     */
    public static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        } else {
            long result = 1;
            for (int i = 2; i <= n; i++) {
                result *= i;
            }
            return result;
        }
    }
}

代码解释：

1. 主方法 main：

• 定义一个变量 sum 来存储阶乘的和。
• 使用一个 for 循环从1遍历到20，调用 factorial 方法计算每个数的阶乘，并将结果累加到 sum 中。
• 最后，打印出计算得到的和。

2. 阶乘方法 factorial：

• 接受一个整数 n 作为参数。
• 如果 n 是0或1，直接返回1（因为0! = 1! = 1）。
• 否则，使用一个 for 循环从2遍历到 n，计算阶乘值并返回。

注意事项：

• 由于20!是一个非常大的数，使用 long 类型来存储结果是合适的。如果需要处理更大的数，可以考虑使用 BigInteger 类。
• 这个程序假设输入的范围是从1到20，因此没有进行额外的输入验证。

再来看一个更详细的版本，同样实现相同功能，但结构更清晰：

public class FactorialSum {

    // 计算n的阶乘
    public static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        long result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    // 主函数
    public static void main(String[] args) {
        int n = 20; // 要计算的项数
        long sum = 0; // 存储总和

        // 计算1 + 2! + 3! + ... + 20!
        for (int i = 1; i <= n; i++) {
            sum += factorial(i);
        }

        // 输出结果
        System.out.println("1 + 2! + 3! + ... + 20! 的和是: " + sum);
    }
}

代码解释

1. factorial 方法：

• 这个方法用于计算给定整数 n 的阶乘。
• 如果 n 是 0 或 1，直接返回 1（因为 0! 和 1! 都等于 1）。
• 否则，初始化一个变量 result 为 1，然后从 2 循环到 n，将每个数乘到 result 上。
• 最后返回 result。

2. main 方法：

• 定义一个变量 n，表示要计算的项数（在这个例子中是 20）。
• 初始化一个变量 sum 为 0，用于存储最终的和。
• 使用一个 for 循环从 1 到 n，在每次循环中调用 factorial 方法计算当前项的阶乘，并将其加到 sum 上。
• 循环结束后，输出计算结果。

注意事项

• 数据类型选择：由于阶乘增长非常快，即使是 20! 也已经是一个相当大的数，因此这里使用 long 类型来存储结果。如果需要计算更大的阶乘，可能需要使用 BigInteger 类。
• 性能优化：在实际应用中，如果需要频繁计算阶乘，可以考虑使用缓存（例如，使用一个数组或哈希表）来存储已经计算过的阶乘值，以避免重复计算。

总结

从最基本的循环实现到利用递推关系优化，这个小题目其实覆盖了不少编程要点：方法抽象、类型选型、时空权衡。不管你是刚接触Ja va的新手，还是想回顾基础的老手，亲手跑一遍这段代码、观察结果的变化，都是挺有意思的一件事。当然，如果真要处理更大的阶乘，比如100!，那 long 就不够用了，得请出 BigInteger，那就是另一个话题了。