Collections之二分查找

源码如下：

/**
     * Searches the specified list for the specified object using the binary
     * search algorithm.  The list must be sorted into ascending order
     * according to the {@linkplain Comparable natural ordering} of its
     * elements (as by the {@link #sort(List)} method) prior to making this
     * call.  If it is not sorted, the results are undefined.  If the list
     * contains multiple elements equal to the specified object, there is no
     * guarantee which one will be found.
     *
     * <p>This method runs in log(n) time for a "random access" list (which
     * provides near-constant-time positional access).  If the specified list
     * does not implement the {@link RandomAccess} interface and is large,
     * this method will do an iterator-based binary search that performs
     * O(n) link traversals and O(log n) element comparisons.
     *
     * @param  list the list to be searched.
     * @param  key the key to be searched for.
     * @return the index of the search key, if it is contained in the list;
     *           otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>.  The
     *           <i>insertion point</i> is defined as the point at which the
     *           key would be inserted into the list: the index of the first
     *           element greater than the key, or <tt>list.size()</tt> if all
     *           elements in the list are less than the specified key.  Note
     *           that this guarantees that the return value will be &gt;= 0 if
     *           and only if the key is found.
     * @throws ClassCastException if the list contains elements that are not
     *           <i>mutually comparable</i> (for example, strings and
     *           integers), or the search key is not mutually comparable
     *           with the elements of the list.
     */

private static final int BINARYSEARCH_THRESHOLD   = 5000;//二分查找的阈值

public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    if(list instanceof RandomAccess || list.size() < BINARYSEARCH_THRESHOLD)//RandomAccess，是一个接口，用来标记一个list是支持高性能随机访问的
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

private static <T> int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key) {
    int low = 0;
    int high = list.size() - 1;
    while(low <= high) {
        int mid = (low + high) >>> 1;//>>> 无符号右移，空位补0;右移一位，相当于除以2，但右移的运算速度更快，若使用(low+high)/2求中间位置容易溢出
        Comparable<? super T> midVal = list.get(mid);
        int cmp = midVal.compareTo(key);
        
        if(cmp < 0)            
            low = mid + 1;
        else if(cmp > 0)
            high = mid - 1;
        else
            return mid;//key found
    }
    return  -(low + 1);//key not found
}

private static <T> int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key) {
    int low = 0;
    int high = list.size() - 1;
    ListIterator<? extends Comparable<? super T>> i = list.listInterator();
    while (low <= high) {
        int mid = (low + high) >>> 1;
        Comparable<? super T> midVal = get(i, mid);
        int cmp = midVal.compareTo(key);
        
        if(cmp < 0) {
            low = mid + 1;
        } else if(cmp > 0) {
            high = mid - 1;
        } else {
            return mid;// key found
        }
    }
    return -(low + 1);// key not found        
}

注：

（1）list需先按照升序排好;

（2）如果list中有重复的元素，结果是不确定的;

（3）List<? extends Comparable<? super T>>，java泛型，<? extends T> 表示类型的上界，表示参数的类型的可能是T或是T的子类；<? super T> 表示类型的下界，表示参数的类型是此类型T的父类型，直至Object;