#范围检查消除

// 可能抛出 ArrayIndexOutOfBoundsException
public int getElement(int[] arr, int index) {
    return arr[index];  // 需要检查 index 是否在范围内
}

// 边界检查的字节码
public int getElement(int[], int);
  0: aload_1           // 加载数组
  1: iload_2           // 加载索引
  2: aload_1           // 加载数组
  3: arraylength       // 获取数组长度
  4: if_icmpge 9       // if index >= length, throw
  5: aload_1           // 加载数组
  6: iload_2           // 加载索引
  7: iaload            // 访问元素
  8: ireturn
  9: new ArrayIndexOutOfBoundsException
  // ...

// 优化前
public int sum(int[] arr) {
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        // arr[i] - 每次迭代都检查
    }
}

// 优化后
public int sum(int[] arr) {
    int sum = 0;
    int length = arr.length;  // 外提
    for (int i = 0; i < length; i++) {
        // arr[i] - 无需检查
    }
}

// 索引范围已知
public int getFirst(int[] arr) {
    return arr[0];  // 已知 0 在范围内
}

public int getLast(int[] arr) {
    return arr[arr.length - 1];  // 已知在范围内
}

// 优化前
for (int i = 0; i < n; i++) {
    arr[i] = i;  // 每次检查
}

// 优化后
int len = arr.length;  // 外提检查
for (int i = 0; i < n && i < len; i++) {
    arr[i] = i;  // 减少检查
}

// 优化前
public int process(int[] arr) {
    return arr[0] + arr[1] + arr[2];
}

// 优化后
// JIT 判断 0, 1, 2 都在范围内
public int process(int[] arr) {
    // 无边界检查
    return arr[0] + arr[1] + arr[2];
}

// 优化前
for (int i = 1; i < arr.length; i++) {
    arr[i] = arr[i] + arr[i-1];  // 两个边界检查
}

// 优化后
// 依赖关系已知，减少检查
for (int i = 1; i < arr.length; i++) {
    // 只需检查一次
    arr[i] = arr[i] + arr[i-1];
}

// 可确定
for (int i = 0; i < arr.length; i++) {
    arr[i] = i;  // i < arr.length 已知
}

// 不可确定
for (int i = 0; i < n; i++) {
    if (i >= arr.length) break;  // 复杂条件
}

// 可确定
int[] arr = new int[10];
arr[5] = 1;  // 已知 5 < 10

// 不可确定
int[] arr = getArray();
arr[5] = 1;  // 长度未知

// 单调递增
for (int i = 0; i < arr.length; i++) {
    arr[i] = i;  // i 单调递增
}

// 复杂变化
for (int i = 0; i < arr.length; i++) {
    i = someFunction(i);  // i 可能跳跃
}

// 性能测试
public class RangeCheckTest {
    
    // 无优化
    public long baseline(int[] arr) {
        long sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];  // 每次边界检查
        }
        return sum;
    }
    
    // 优化后
    public long optimized(int[] arr) {
        long sum = 0;
        int len = arr.length;  // 外提
        for (int i = 0; i < len; i++) {
            sum += arr[i];  // 边界检查减少
        }
        return sum;
    }
}

// JIT 日志中可能看到范围检查消除
// 但通常作为编译优化的一部分

// 无法消除
public int get(int[] arr, int index) {
    return arr[index];  // index 动态
}

// 无法消除
public int get(int[] arr, int index) {
    return arr[index];  // index 来自用户输入
}

// 可能无法完全消除
public void process(int[] arr, int start, int end) {
    for (int i = start; i < end; i++) {
        if (i >= arr.length) break;  // 复杂条件
    }
}

// 推荐
for (int i = 0; i < arr.length; i++) {
    arr[i] = compute(i);
}

// 不推荐
for (int i = 0; i < arr.length; i++) {
    int idx = computeIndex(i);  // 复杂索引
    arr[idx] = compute(i);
}

// for-each 可能帮助 JIT
for (int element : arr) {
    // 使用 element 而不是 arr[i]
}

// 推荐
int len = arr.length;
for (int i = 0; i < len; i++) {
    arr[i] = i;
}

// 不推荐
for (int i = 0; i < arr.length; i++) {
    arr[i] = i;
}

// 循环展开后
for (int i = 0; i < arr.length; i += 4) {
    arr[i] = i;       // 检查 i
    arr[i+1] = i+1;  // 可能检查 i+1
    arr[i+2] = i+2;  // 可能检查 i+2
    arr[i+3] = i+3;  // 可能检查 i+3
}

// SIMD 优化后
for (int i = 0; i < arr.length; i += 8) {
    // 一次加载 8 个元素
    // 无需每次检查
}