[改善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中的前后位置)