高效解决二分查找中的数组越界问题

public static int binarySearch(double [] array, double find){
    int first = 0;
    int last = array.length; // 错误：last应该指向最后一个元素的索引，而不是数组长度
    int mid = (first + last ) / 2; // 初次计算mid可能基于错误的last
    while(first <= last){ // 循环条件可能导致越界访问
        if(array[mid] < last){ // 错误：这里应与find比较，而不是last
            first = mid +1;
        }else if(array[mid] == find){
            return mid;
        }else{
            last = mid -1;
        }
        mid = (first + last) / 2; // mid的更新必须在每次循环迭代后
    }
    if(first > last){ // 冗余检查，循环结束后自然会返回-1
        return -1;
    }
    return -1;
}

import java.util.Arrays;
import java.util.Random;

class Search {
    public static void main(String[] args) {
        // 生成一个包含随机双精度浮点数的数组
        double[] arrayData = new double[9999];
        Random rand = new Random();
        for (int i = 0; i < arrayData.length; i++) {
            arrayData[i] = rand.nextDouble() * 9999; // 生成0到9999之间的随机数
        }

        // 对数组进行排序，二分查找的前提是数组必须有序
        Arrays.sort(arrayData);

        // 随机选择一个目标值进行查找
        double targetValue = rand.nextDouble() * 9999; 

        // 打印查找结果
        int index = binarySearch(arrayData, targetValue);
        if (index != -1) {
            System.out.println("目标值 " + targetValue + " 在数组中的索引是: " + index);
            // 验证：打印实际找到的值，看是否与目标值匹配
            System.out.println("实际找到的值是: " + arrayData[index]);
        } else {
            System.out.println("目标值 " + targetValue + " 不在数组中。");
        }

        // 也可以尝试查找数组中实际存在的值进行验证
        if (arrayData.length > 0) {
            double existingValue = arrayData[arrayData.length / 2]; // 查找中间的一个值
            int existingIndex = binarySearch(arrayData, existingValue);
            System.out.println("\n尝试查找数组中已存在的值: " + existingValue);
            System.out.println("索引是: " + existingIndex);
        }
    }

    /**
     * 在有序的双精度浮点数数组中执行二分查找。
     *
     * @param array 有序的双精度浮点数数组。
     * @param find 要查找的目标值。
     * @return 如果找到目标值，返回其索引；否则返回 -1。
     */
    public static int binarySearch(double[] array, double find) {
        int first = 0;
        int last = array.length - 1; // 修正：last 初始化为数组的最后一个有效索引

        // 循环条件：当查找范围有效时继续
        while (first <= last) {
            // 优化：计算中间索引，避免 (first + last) 溢出（尽管对于int通常不是问题，但仍是良好实践）
            int mid = first + (last - first) / 2; 

            if (array[mid] == find) {
                return mid; // 找到目标值，返回索引
            } else if (array[mid] < find) {
                // 目标值在中间元素的右侧，缩小查找范围
                first = mid + 1;
            } else {
                // 目标值在中间元素的左侧，缩小查找范围
                last = mid - 1;
            }
        }
        return -1; // 循环结束仍未找到目标值，返回 -1
    }
}