Java-用于搜索子字符串的比较器

我试图使用二进制搜索来查找包含子字符串的字符串

ArrayList<String> ch = new ArrayList<String>();
    ch.add("qwerty");
    ch.add("asdfghjkl");
    ch.add("c");
    ch.add("d");
    ch.add("e");
    Comparator<String> comparator = new Comparator<String>() {
        public int compare(String node1, String node2) {
            if (node1.contains(node2)) {
                return 0;
            }
            return node1.indexOf(node2);
        }
    };


    int pos2 = Collections.binarySearch(ch, "sdf", comparator);

ArrayList ch=new ArrayList（）；
总附录（“qwerty”）；
ch.add（“asdfghjkl”）；
ch.add（“c”）；
第3章，添加（“d”）；
ch.add（“e”）；
比较器比较器=新比较器（）{
公共整数比较（字符串节点1、字符串节点2）{
if（节点1.contains（节点2））{
返回0；
}
返回node1.indexOf（node2）；
}
};
int pos2=Collections.binarySearch（ch，“sdf”，comparator）；

是否可以使用binarysearch而不是使用循环。这给了我一个不正确的索引

我试图避免使用string.substring（x，y），其中x和y是固定值。

方法用于搜索精确匹配，而不是基于某个子字符串或某个方法的匹配。另外，要使

binarySearch

工作，您应该有一个排序数组，它基于传递给

binarySearch

方法的

Comparator

（不过，这在这里并不重要，因为它也不起作用）

是否可以使用binarysearch而不是使用循环

我认为不使用循环就不可能做到这一点。如果您真的担心性能，可以编写自己的二进制搜索实现，它检查

包含（）

，而不是相等。

方法用于搜索精确匹配，而不是基于某个子字符串或某个方法的匹配。另外，要使

binarySearch

工作，您应该有一个排序数组，它基于传递给

binarySearch

方法的

Comparator

（不过，这在这里并不重要，因为它也不起作用）

是否可以使用binarysearch而不是使用循环

我认为不使用循环就不可能做到这一点。如果您真的担心性能，可以编写自己的二进制搜索实现，它检查

包含（）

，而不是相等。

方法用于搜索精确匹配，而不是基于某个子字符串或某个方法的匹配。另外，要使

binarySearch

工作，您应该有一个排序数组，它基于传递给

binarySearch

方法的

Comparator

（不过，这在这里并不重要，因为它也不起作用）

是否可以使用binarysearch而不是使用循环

我认为不使用循环就不可能做到这一点。如果您真的担心性能，可以编写自己的二进制搜索实现，它检查

包含（）

，而不是相等。

方法用于搜索精确匹配，而不是基于某个子字符串或某个方法的匹配。另外，要使

binarySearch

工作，您应该有一个排序数组，它基于传递给

binarySearch

方法的

Comparator

（不过，这在这里并不重要，因为它也不起作用）

是否可以使用binarysearch而不是使用循环

---

我认为不使用循环就不可能做到这一点。如果您真的担心性能，可以编写自己的二进制搜索实现，它检查

包含（）

，而不是相等性。

在搜索API中提到的项之前，必须对列表进行排序

，T）

---

此外，compare函数应该返回-1,0,1作为响应，看起来它没有做它应该做的事情

在搜索API中提到的项目之前，必须对列表进行排序

，T）

---

此外，compare函数应该返回-1,0,1作为响应，看起来它没有做它应该做的事情

在搜索API中提到的项目之前，必须对列表进行排序

，T）

---

此外，compare函数应该返回-1,0,1作为响应，看起来它没有做它应该做的事情

在搜索API中提到的项目之前，必须对列表进行排序

，T）

---

此外，compare函数应该返回-1,0,1作为响应，看起来它没有做它应该做的事情

问题：您只能对已排序的集合进行二进制搜索。
解决方案：在调用

binarySearch（）

之前，使用

比较器对集合进行排序

问题：比较器必须满足接口要求。例如，排序函数必须是可传递的
解决方案：实现这一点的唯一可能方法是对每个字符串使用
比较器

public static void main(String[] args) {
    ArrayList<String> ch = new ArrayList<String>();
    ch.add("qwerty");
    ch.add("asdfghjkl");
    ch.add("c");
    ch.add("d");
    ch.add("e");
    final String fixedString = "sdf";
    Comparator<String> comparator = new Comparator<String>() {
        public int compare(String node1, String node2) {
            boolean node1Contains = node1.contains(fixedString);
            boolean node2Contains = node2.contains(fixedString);
            if (node1Contains && !node2Contains) {
                return 1;
            } else if (!node1Contains && node2Contains ) {
                return -1;
            } else {
                return 0;
            }
        }
    };

    Collections.sort(ch, comparator);
    int pos2 = Collections.binarySearch(ch, fixedString, comparator);
    System.out.println("Sorted collection: "+ch);
    System.out.println("Index found: "+pos2);
}

底线是：
不考虑字符串的大小和多次调用
contains（）
的成本：


排序将采用
O（n log（n））
（其中
n
是字符串数），搜索将采用
O（log（n））
，因此，总体而言，
O（n log（n））
循环将需要
O（n）

因此，除非您想获得类似“索引中包含搜索字符串的字符串（更接近其开头）”之类的内容，否则最好循环执行。
问题：您只能对已排序的集合进行二进制搜索。

解决方案：在调用
binarySearch（）
之前，使用
比较器对集合进行排序

问题：比较器必须满足接口要求。例如，排序函数必须是可传递的
解决方案：实现这一点的唯一可能方法是对每个字符串使用
比较器

public static void main(String[] args) {
    ArrayList<String> ch = new ArrayList<String>();
    ch.add("qwerty");
    ch.add("asdfghjkl");
    ch.add("c");
    ch.add("d");
    ch.add("e");
    final String fixedString = "sdf";
    Comparator<String> comparator = new Comparator<String>() {
        public int compare(String node1, String node2) {
            boolean node1Contains = node1.contains(fixedString);
            boolean node2Contains = node2.contains(fixedString);
            if (node1Contains && !node2Contains) {
                return 1;
            } else if (!node1Contains && node2Contains ) {
                return -1;
            } else {
                return 0;
            }
        }
    };

    Collections.sort(ch, comparator);
    int pos2 = Collections.binarySearch(ch, fixedString, comparator);
    System.out.println("Sorted collection: "+ch);
    System.out.println("Index found: "+pos2);
}

底线是：
不考虑字符串的大小和多次调用
contains（）
的成本：


排序将采用
O（n log（n））
（其中
n
i