Java中全局变量与数组的声明、使用及最佳实践

public class GlobalDataContainer {
    // 声明一个私有的静态整型数组，作为类级别的“全局”数组
    private static int[] globalAuxArray;

    // 声明一个私有的静态整型变量
    private static int globalCounter = 0;

    // 静态代码块，可以在类加载时初始化静态成员
    static {
        // globalAuxArray = new int[10]; // 可以在这里进行初始化
    }

    // 示例方法，访问并修改静态变量
    public static void incrementCounter() {
        globalCounter++;
    }

    public static int getCounter() {
        return globalCounter;
    }

    // ... 其他方法 ...
}

// 推荐的数组声明方式
int[] recommendedArray = new int[10];

// 同样合法但不太推荐的方式
int lessRecommendedArray[] = new int[10];

import java.util.Arrays; // 导入用于打印数组的工具类

public class PrefixSumCalculator {

    /**
     * 计算并返回给定数组的前缀和数组。
     * 前缀和数组的每个元素表示原始数组从开头到当前索引的和。
     * 例如：对于 arr = {2, 5, 7}，其前缀和数组为 {2, 7, 14}。
     *
     * @param arr 原始整型数组。
     * @return 包含前缀和的整型数组。如果输入数组为空，返回一个空数组。
     */
    public static int[] calculatePrefixSum(int[] arr) {
        if (arr == null || arr.length == 0) {
            return new int[0]; // 处理空数组情况
        }

        int n = arr.length;
        int[] prefixSumArray = new int[n]; // 局部变量，仅在方法内部有效

        prefixSumArray[0] = arr[0]; // 第一个元素的前缀和就是它本身
        for (int i = 1; i < n; i++) {
            // 当前元素的前缀和 = 当前元素值 + 上一个元素的前缀和
            prefixSumArray[i] = arr[i] + prefixSumArray[i - 1];
        }
        return prefixSumArray; // 返回计算好的前缀和数组
    }

    /**
     * 根据已经计算好的前缀和数组，计算指定区间的和。
     * 使用公式：sum(start, end) = prefixSumArray[end] - prefixSumArray[start - 1]
     * (当 start = 0 时，sum = prefixSumArray[end])
     *
     * @param prefixSumArray 已经计算好的前缀和数组。
     * @param start          区间起始索引（包含）。
     * @param end            区间结束索引（包含）。
     * @return 区间 [start, end] 的和。
     * @throws IllegalArgumentException 如果索引无效。
     */
    public static int getRangeSum(int[] prefixSumArray, int start, int end) {
        // 参数校验，确保索引在合法范围内
        if (prefixSumArray == null || prefixSumArray.length == 0) {
            throw new IllegalArgumentException("Prefix sum array cannot be null or empty.");
        }
        if (start < 0 || end >= prefixSumArray.length || start > end) {
            throw new IllegalArgumentException(
                String.format("Invalid start (%d) or end (%d) indices for array of length %d.",
                              start, end, prefixSumArray.length));
        }

        if (start == 0) {
            return prefixSumArray[end]; // 如果起始索引为0，直接返回到结束索引的前缀和
        }
        // 否则，使用前缀和差值计算区间和
        return prefixSumArray[end] - prefixSumArray[start - 1];
    }

    public static void main(String[] args) {
        int[] arr = {2, 5, 7, 3, 4, 5, 3};
        int start = 2; // 对应原始数组的索引 2 (值为 7)
        int end = 5;   // 对应原始数组的索引 5 (值为 5)

        System.out.println("原始数组: " + Arrays.toString(arr));

        // 步骤1: 计算前缀和数组
        int[] prefixSumResult = calculatePrefixSum(arr);
        System.out.println("前缀和数组: " + Arrays.toString(prefixSumResult));
        // 对于 arr = {2, 5, 7, 3, 4, 5, 3}
        // prefixSumResult 应该是 {2, 7, 14, 17, 21, 26, 29}

        // 步骤2: 利用前缀和数组查询指定区间 [start, end] 的和
        int sum = getRangeSum(prefixSumResult, start, end);
        System.out.println(String.format("区间 [%d, %d] 的和为: %d", start, end, sum));
        // 预期结果：arr[2]+arr[3]+arr[4]+arr[5] = 7+3+4+5 = 19
        // 使用前缀和：prefixSumResult[5] - prefixSumResult[2-1] = prefixSumResult[5] - prefixSumResult[1] = 26 - 7 = 19
    }
}