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