Java 字符串特定部分的二进制搜索

这是

ArrayList

中的字符串

9*8*0.01548

。我需要基于

Double

值进行二进制搜索，即

0.01548

以找到搜索值的紧密匹配

ArrayList

包含约100万条记录<代码>拆分在优化方面似乎不是一个好的选择。 我尝试了以下代码，但它不起作用，因为列表中间值是根据列表大小

3

计算的。二进制搜索本身很好，我只是为了澄清问题而添加，如果

Double

值在

arrayListvalues

中，那么二进制搜索工作正常

可能的替代方案是什么

如何使其工作 下表为：

public static <T> int binarySearch(List<T> list, T key, Comparator<T> compare) {
int low, high, med, comp;
        T temp;
        high = list.size();
        low = 0;
        med = (high + low) / 2;

        while (high != low + 1) {
            temp = list.get(med);
            comp = compare.compare(temp, key);

            if (comp == 0) {
                return med;
            } else if (comp < 0) {
                low = med;
            } else {
                high = med;
            }

            med = (high + low) / 2;
        }

        return med;
    }

publicstaticintbinarysearch（列表、T键、比较器比较）{
int低、高、中、comp；
温度；
高=list.size（）；
低=0；
中等=（高+低）/2；
while（高！=低+1）{
temp=列表获取（med）；
comp=比较。比较（温度、键）；
如果（comp==0）{
返回医学院；
}否则如果（组件<0）{
低=中等；
}否则{
高=中等；
}
中等=（高+低）/2；
}
返回医学院；
}

比较器

public static class doubleComparator implements Comparator<String> {

 @Override
        public int compare(String s1, String s2) {
            String[] d1 = s1.split("*"); //this
            String[] d2 = s2.split("*"); //that
            if (Double.parseDouble(d1[2]) < Double.parseDouble(d2[2])) {
                return -1;
            } else if (Double.parseDouble(d2 [2]) > Double.parseDouble(d2[2])) {
                return 1;
            } else {
                return 0;
            }
        }
    }

公共静态类doubleComparator实现Comparator{
@凌驾
公共整数比较（字符串s1、字符串s2）{
字符串[]d1=s1.split（“*”）；//这个
字符串[]d2=s2.split（“*”）；//该字符串
if（Double.parseDouble（d1[2]）Double.parseDouble（d2[2]））{
返回1；
}否则{
返回0；
}
}
}

主要

publicstaticvoidmain（字符串[]args）{
ArrayList strArray=新的ArrayList（）；
strArray.添加（“1*2*0.1”）；
加上（“3*4*0.5”）；
strArray.添加（“5*6*0.6”）；
strArray.添加（“7*8*0.7”）；
加上（“9*10*0.8”）；
strArray.添加（“11*12*0.9”）；
int key=binarySearch（strArray，“45*60*0.3”，新的doubleComparator（））；
System.out.println（“搜索”45*60*0.3:“\tKey:+key+”\tValue:+strArray.get（key））；
}

考虑在此处更改核心元素：为什么要使用带字符串的ArrayList；如果你将有一百万以上的条目；你需要快点去拿双份的吗

为什么不进行预计算：当您获取初始记录时；把它们分成两份清单；一个包含完整字符串的。。。另一个仅包含（已计算和强制转换）双值？如果对象的数量不变，则为Heck；您甚至可以将它们放在一个数组中（对于一百万个条目来说，array[double]的成本比ArrayList小得多）

含义：有时，试图围绕表现不佳的数据构建“高效”算法是浪费时间。相反，请更改数据的表示形式，以便能够有效地处理它

---

当然，这取决于。。。数据更改。。。数据需要（重新）计算。。。这些搜索会发生。只是说你不应该专注于“正确地进行搜索”。

如果元素按搜索的相同属性排序，则二进制搜索只适用于列表。因此，只有当列表按每个

字符串中的最后一个值（浮点值）排序时，搜索才会起作用

下一个问题很简单，排序/搜索的相关值是列表的最后一个元素，因此为二进制搜索构建
比较器非常困难。最快的方法（就运行时而言）是为比较构建自己的循环，并以允许更快比较的方式重新组织字符串。例如：不要使用
“9*8*0.01548”
，而是使用
“0.01548*9*8”
加快搜索速度

 public static void main(String[] args) {
 ArrayList<String> strArray= new ArrayList<String>();
        strArray.add("1*2*0.1");
        strArray.add("3*4*0.5");
        strArray.add("5*6*0.6");
        strArray.add("7*8*0.7");
        strArray.add("9*10*0.8");
        strArray.add("11*12*0.9");
        int key = binarySearch(strArray, "45*60*0.3", new doubleComparator());
        System.out.println("Search for "45*60*0.3:"\tKey:" + key + "\tValue:" + strArray.get(key));
}