[改善Java代碼]不推薦使用binarySearch對列表進行檢索

對一個列表進行檢索時,我們使用的最多的是indexOf方法,它簡單好用,而且也不會出錯,雖然它只能檢索到第一個符合條件的值,但是我們可以生成子列表后再檢索.這樣也就可以查找到所有符合條件的值了.

Collections工具類也提供了一個檢索的方法:binarySearch,這個是干什么的?該方法也是對一個列表進行檢索的,可以查找出指定的索引值,但是在使用這個方法時就有一些注意事項,看代碼:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        List<String> cities = new ArrayList<String>();
        cities.add("上海");
        cities.add("廣州");
        cities.add("廣州");
        cities.add("北京");
        cities.add("天津");
        //indexOf方法取得索引值
        int index1 = cities.indexOf("廣州");
        //binarySearch查找到索引值
        int index2 = Collections.binarySearch(cities, "廣州");
        System.out.println("索引值(indexOf)："+index1);
        System.out.println("索引值（binarySearch)："+index2);
    }
}

 運行結果:

索引值(indexOf)：1
索引值（binarySearch)：2

 

結果不一樣,雖然有兩個"廣州"這樣的元素.但是返回的結果都應該是1才對,為何binarySearch返回的結果是2,問題就出現在2分法搜索上,二分法搜索就是"折半折半再折半"簡單,效率高.

看JDK中源碼是如何實現的:

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)
            return Collections.indexedBinarySearch(list, key);//隨機存取列表或者元素數量少於5000的順序列表
        else
            return Collections.iteratorBinarySearch(list, key);//元素數量大於50000的順序存取列表
}

 

 ArrayList實現了RandomAccess接口,是一個順序存取列表,使用了indexBinarySearch方法,代碼如下:

    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;//中間索引,無符號右移1位
            Comparable<? super T> midVal = list.get(mid);//中間值
            int cmp = midVal.compareTo(key);//比較中間值
11             //重置上界和下界   
            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.listIterator();

        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
    }

 

 以上就是二分法搜索的Java版實現,首先是獲得中間索引值,我們的例子中是2,那么索引值是2的元素值是多少?正好是"廣州",於是返回索引值2.正確沒有問題.

那么再看indexOf的實現:

    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

 

 indexOf方法就是一個遍歷,找到第一個元素值相等則返回.

兩者的算法都沒有問題,是我們用錯了binarySearch的用法,因為二分法查詢要有一個首要的前提,數據集已經實現了升序排列,否則二分法查找的值是不准確的.不排序怎么確定是在比中間值小的區域還是比中間值大的區域呢?

二分法排序首先要排序,這是二分法的首要條件.

問題清楚了,使用Collection.sort排序即可,但是這樣真的可以解決嗎?元素數據是從Web或數據庫中傳過來的,原本是一個有規則的業務數據,為了查找一個元素對其排序,改變了元素在列表中的位置.那誰來保證業務規則的正確性呢?

所以binarySearch在此處首先了.當然可以拷貝一個數組,然后再排序,再使用binarySearch查找指定值,也是可以解決問題.

當然使用binarySearch的二分法查找比indexOf遍歷算法性能上高很多,特別是在大數據集而且目標值又接近尾部時,binarySearch方法與indexOf相比,性能上會提升幾十倍,因此在從性能的角度考慮時可以選擇binarySearch.

//==================測試binarySearch()和indexOf的時間=========

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;


public class Client {
    public static void main(String[] args) {
        int max =1200000;
        List<String> cities = new ArrayList<String>();
        for(int i=0;i<max;i++){
            cities.add(i+"");
        }
        //indexOf方法取得索引值
        long start = System.nanoTime();
        int index1 = cities.indexOf((max-5)+"");
        long mid = System.nanoTime();
        System.out.println(mid - start);
        //binarySearch查找到索引值
        int index2 = Collections.binarySearch(cities, (max-5)+"");
        long end = System.nanoTime();
        System.out.println(end - mid);
        System.out.println("索引值(indexOf)："+index1);
        System.out.println("索引值（binarySearch)："+index2);
    }
}

 

運行輸出:

16876685
408528
索引值(indexOf)：1199995
索引值（binarySearch)：-1201

 

這個地方binarySearch輸出負值....我沒有調查...如果把這個max改的小一點就沒有任何問題.

兩種方式的索引值都一樣.

binarySearch()的索引效率比indexOf高很多...(具體還要看要查找的值在list中的前后位置)