在Java按排序的数组搜索相等，更大或更小的对象

在Java中，我们可以使用二分查找算法来在已排序的数组中搜索特定元素。这个算法的工作原理是将数组分成两部分，然后检查中间元素的值。如果中间元素与目标元素匹配，则算法完成。否则，如果中间元素大于目标元素，则我们只需要在左半部分进行搜索。同样，如果中间元素小于目标元素，则我们只需要在右半部分进行搜索。我们不断重复这个过程，直到找到目标元素或确定它不在数组中。

以下是一个用Java实现的二分查找算法的示例：

public static int binarySearch(int[] arr, int key) {
    int low = 0;
    int high = arr.length - 1;

    while (low <= high) {
        int mid = (low + high) / 2;

        if (arr[mid] < key) {
            low = mid + 1;
        } else if (arr[mid] > key) {
            high = mid - 1;
        } else {
            return mid;
        }
    }

    return -1; // 如果没找到返回-1
}

在这个示例中，我们将数组分成三个部分：低、中、高。我们比较目标元素与中间元素，如果它小于中间元素，则我们只需要在低部分继续搜索。同样，如果目标元素大于中间元素，则我们只需要在高部分继续搜索。如果中间元素等于目标元素，则我们可以返回中间元素的索引作为结果。

二分查找算法的时间复杂度为O(log n)，其中n是数组的大小。这比线性搜索要快得多，尤其在数组很大的情况下。要使用二分查找算法进行搜索，数组必须是有序的。如果数组未排序，则可以使用Arrays.sort方法对其进行排序。

除了查找相等的对象，我们还可以使用二分查找算法来查找比目标元素更大或更小的对象。以下是查找比目标元素更大的对象的示例：

public static int nextGreaterElement(int[] arr, int key) {
    int low = 0;
    int high = arr.length - 1;

    while (low <= high) {
        int mid = (low + high) / 2;

        if (arr[mid] <= key) {
            low = mid + 1;
        } else {
            if (mid == 0 || arr[mid - 1] <= key) {
                return mid;
            } else {
                high = mid - 1;
            }
        }
    }

    return -1; // 如果找不到返回-1
}

在这个示例中，我们比较目标元素与中间元素。如果目标元素小于或等于中间元素，则我们只需要在高部分继续搜索。否则，我们在低部分继续搜索，并在中间元素大于目标元素且中间元素的前一个元素小于或等于目标元素时返回中间元素的索引。如果未找到大于目标元素的元素，则返回-1。

同样，我们可以使用类似的方式来查找比目标元素更小的对象。以下是此类搜索的示例：

public static int nextSmallerElement(int[] arr, int key) {
    int low = 0;
    int high = arr.length - 1;

    while (low <= high) {
        int mid = (low + high) / 2;

        if (arr[mid] >= key) {
            high = mid - 1;
        } else {
            if (mid == arr.length - 1 || arr[mid + 1] >= key) {
                return mid;
            } else {
                low = mid + 1;
            }
        }
    }

    return -1; // 如果找不到返回-1
}

这两个示例的时间复杂度也是O(log n)。注意，在执行这些搜索之前，数组必须是已排序的。

总之，我们可以使用二分查找算法来搜索相等、更大或更小的对象。这是一种高效的算法，可以在有序数组中快速找到目标元素。