Java 为什么compareTo在应该为false时返回true？

我正在调试数据结构类项目中错误的搜索返回。当前的这个项目要求我们构建一个有序展开的链表，并对内容进行搜索，然后返回一个从包含的起点到独占的终点的项目子列表。为此，我必须搜索内部数组以找到起始元素的索引点。我通过二进制搜索来实现这一点，但由于这只返回找到的第一个匹配项，并且在它之前可能还有其他匹配项，因此我必须返回数组以找到第一个真正的匹配项。我是通过

//get first index match, work backwards
int index= binarySearch(node.items, 0, node.numUsed, item, comp);
while (index>0 && comp.compare(node.items[index], item)==0){
    index--;
}

教授提供了测试代码，该代码将字符串分解，并将每个字符作为一项添加到结构中。他还包括一个嵌套的StringCmp类，该类在上面的二进制搜索声明中被引用为

comp

。他的比较方法是

public int compare(String s1, String s2) {
  cmpCnt++;
  return s1.compareTo(s2);
}

但是，当在从i到o的子列表方法上运行测试时，当

comp.compare（h，i）==0时，此方法将返回一个真值，这将从我编写的搜索类中抛出我的开始结果。我最初用
returnindex++
进行补偿，这足以通过结构测试，但与预期的起点相差了1

那么，当这显然是错误的时候，为什么返回的是正确的呢

编辑添加了子列表方法的打印输出，预计将从i运行到o

输入测试字符串=
abcdefghijklmnopqrstuvxyzaeou
从子列表方法返回：

第1组（使用第4组，共10组）：[h][i][i][j]

组块2（10个中的4个）：[k][l][m][n]

h根本不应该在列表中，但是
comp.compare（node.items[index]，item）==0
返回true，即i==h，这显然是false

编辑两个
项目的第二部分要求我们解析文本文件，从艺术家、标题和歌词字段构建歌曲对象，然后使用前缀对标题进行搜索。这里出现的错误不会出现在单字母和多字母搜索中，因此我认为问题在于测试中的StringCmp嵌套类
 您知道
compare（）
应该返回什么吗？通常，如果第一个参数小于第二个参数，则此类函数返回负值；如果它们相等，则返回0；如果第一个参数大于第二个参数，则返回正值

另外，在阵列上执行排序的是什么？您可以发布您的
binarySearch（）
代码，以便我们查看问题是否存在？
您知道
compare（）
应该返回什么吗？通常，如果第一个参数小于第二个参数，则此类函数返回负值；如果它们相等，则返回0；如果第一个参数大于第二个参数，则返回正值

另外，在阵列上执行排序的是什么？您能否发布您的
binarySearch（）
代码，以便我们查看问题是否存在？
检查compareTo（String）方法

从文档：

返回：如果参数字符串等于此字符串，则返回值0；如果此字符串在字典上小于字符串参数，则值小于0；如果该字符串在字典上大于字符串参数，则该值大于0。
检查compareTo（string）方法

从文档：

返回：如果参数字符串等于此字符串，则返回值0；如果此字符串在字典上小于字符串参数，则值小于0；如果该字符串在字典上大于字符串参数，则该值大于0。
出于好奇，这不是更符合您要执行的操作吗

//get first index match, work backwards
int index= binarySearch(node.items, 0, node.numUsed, item, comp);

for (int i = index; i >= 0; i--) {
    if (comp.compare(node.items[index], item)==0))
        index = i;
}

出于好奇，这不是更符合你的想法吗

//get first index match, work backwards
int index= binarySearch(node.items, 0, node.numUsed, item, comp);

for (int i = index; i >= 0; i--) {
    if (comp.compare(node.items[index], item)==0))
        index = i;
}

因为您实现了自己的二进制搜索，所以应该继续使用它来搜索数组中的第一个匹配元素，而不是在找到匹配项后立即停止

您当前的方法引入了不必要的复杂性，如果您的输入数组包含所有相同的值，则可能会将O（logn）算法更改为O（N）算法

我想你现在的算法看起来像

int low = 0; 
int high = a.length-1;
while (low <= high) {
    int mid = (low + high) / 2;
    int cmp = comp.compare(a[mid], key);
    if (cmp < 0)
        low = mid + 1;
    else if (cmp > 0)
        high = mid - 1;
    else
        return mid;
}
return -1;

int-low=0；
int高=a.length-1；
while（低0）
高=中-1；
其他的
中途返回；
}
返回-1；

用下面的代码替换它应该可以做到这一点

int low = 0;
int high = a.length-1;
while (low < high) {
    int mid = (low + high) / 2;
    int cmp = comp.compare(a[mid], key);
    if (cmp < 0)
        low = mid + 1;
    else
        high = mid;
}
if (comp.compare(a[low], key) == 0)
    return low;
else 
    return -1;

int-low=0；
int高=a.length-1；
while（低<高）{
int mid=（低+高）/2；
int cmp=组件比较（一个[mid]，键）；
if（cmp<0）
低=中+1；
其他的
高=中；
}
如果（组件比较（a[低]，键）==0）
低回报；
其他的
返回-1；
既然您实现了自己的二进制搜索，您应该继续使用它来搜索数组中的第一个匹配元素，而不是在找到匹配项后立即停止

您当前的方法引入了不必要的复杂性，如果您的输入数组包含所有相同的值，则可能会将O（logn）算法更改为O（N）算法

我想你现在的算法看起来像

int low = 0; 
int high = a.length-1;
while (low <= high) {
    int mid = (low + high) / 2;
    int cmp = comp.compare(a[mid], key);
    if (cmp < 0)
        low = mid + 1;
    else if (cmp > 0)
        high = mid - 1;
    else
        return mid;
}
return -1;

int-low=0；
int高=a.length-1；
while（低0）
高=中-1；
其他的
中途返回；
}
返回-1；

用下面的代码替换它应该可以做到这一点

int low = 0;
int high = a.length-1;
while (low < high) {
    int mid = (low + high) / 2;
    int cmp = comp.compare(a[mid], key);
    if (cmp < 0)
        low = mid + 1;
    else
        high = mid;
}
if (comp.compare(a[low], key) == 0)
    return low;
else 
    return -1;

int-low=0；
int高=a.length-1；
while（低<高）{
int mid=（低+高）/2；
int cmp=组件比较（一个[mid]，键）；
if（cmp<0）
低=中+1；
其他的
高=中；
}
如果（组件比较（a[低]，键）==0）
低回报；
其他的
返回-1；
您的while循环

while (index>0 && comp.compare(node.items[index], item)==0){
    index--;
}

当您减少每个匹配的索引时，会将第一个匹配超出1，使您处于不再匹配的索引。对索引-1处的项调用比较器将解决此问题：

while (index>0 && comp.compare(node.items[index-1], item)==0){
    index--;
}

你的while循环

while (index>0 && comp.compare(node.items[index], item)==0){
    index--;
}

当你减少每一个匹配的索引时，超过第一个匹配1，留下一个不再匹配的索引