二分查找也叫折半查找，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0，时间复杂度为 O(logn)。

public class BinarySearch {
    public static void main(String[] args) {
        int[] arrays = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        BinarySearch binarySearch = new BinarySearch();
        System.out.println(binarySearch.search(arrays, 2));
        System.out.println(binarySearch.search(arrays, 0, arrays.length - 1, 2));
    }

    /**
     * 循环实现
     *
     * @param a     数组
     * @param value 目标值
     * @return 目标下标
     */
    public int search(int[] a, int value) {
        int low = 0;
        int high = a.length - 1;
        while (low <= high) {
            // int mid = (low + high) / 2;
            // 避免溢出的写法
            int mid = low + ((high - low) >> 1);
            if (a[mid] == value) {
                return mid;
            } else if (a[mid] < value) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return -1;
    }

    /**
     * 递归实现
     *
     * @param a     数组
     * @param low   左下标
     * @param high  右下标
     * @param value 目标值
     * @return 目标下标
     */
    public int search(int[] a, int low, int high, int value) {
        if (low > high) {
            return -1;
        }

        int mid = low + ((high - low) >> 1);
        if (a[mid] == value) {
            return mid;
        } else if (a[mid] < value) {
            return search(a, mid + 1, high, value);
        } else {
            return search(a, low, mid - 1, value);
        }
    }
}

二分查找的局限性：

1. 二分查找只能用在数据是通过顺序表来存储的数据结构上。如果你的数据是通过其他数据结构存储的，则无法应用二分查找。
2. 二分查找针对的是有序数据。