Java 如何使用binarySearch或其他方法在字符串数组中搜索字符串？

使用binarySearch永远不会返回正确的索引

int j = Arrays.binarySearch(keys,key);

其中键的类型为

String[]

，键的类型为

String

我读过一些关于需要对数组进行排序的文章，但是如果是这样的话，我该怎么做呢

考虑到这一切，我只想知道：

---

如何在字符串数组（小于1000）中搜索字符串？

java.util.array.sort（myArray）

这就是binarySearch的工作原理——它假设排序，以便更快地查找

如果您只想在O（n）时间内在列表中查找某些内容，请不要使用BinarySearch，而是使用。此页面上发布的此算法的所有其他实现都是错误的，因为当数组包含空值或该项不存在时，它们会失败

public static int indexOf(final Object[] array, final Object objectToFind, int startIndex) {
    if (array == null) {
        return -1;
    }
    if (startIndex < 0) {
        startIndex = 0;
    }
    if (objectToFind == null) {
        for (int i = startIndex; i < array.length; i++) {
            if (array[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = startIndex; i < array.length; i++) {
            if (objectToFind.equals(array[i])) {
                return i;
            }
        }
    }
    return -1;
}

public static int indexOf（final Object[]数组，final Object objectToFind，int startIndex）{
if（数组==null）{
返回-1；
}
如果（起始索引<0）{
startIndex=0；
}
if（objectToFind==null）{
对于（int i=startIndex；i
在Java中所有重载的binarySearch版本中，没有一个版本采用String参数。但是，有三种类型的二进制搜索可能对您的情况有所帮助：

静态int二进制搜索（char[]a，char键）；
静态int二进制搜索（对象[]a，对象键）；
静态int二进制搜索（T[]a，T键，比较器c）
来自维基百科：

在计算机科学中，二进制搜索是一种算法，通过检查中间位置，去掉列表的一半，然后对剩余的一半进行搜索，从而确定元素在已排序列表中的位置。[1][2]如果中间元素等于查找的值，则已找到位置；否则，将根据元素是否大于或小于中间元素来选择上半部分或下半部分进行搜索。”

因此，二进制搜索的先决条件是对数据进行排序。它必须被排序，因为它将数组一分为二并查看中间的元素。如果中间元素是它正在寻找的，那么它就完成了。如果中间的元素较大，则取数组的下半部分。如果中间的元素较小，它将显示数组的上半部分。然后重复这个过程（在中间看……）直到找到元素（或不是）。< /P>
如果数据未排序，算法将无法工作

所以你可以这样做：

final String[] data;
final int      index;

data = new String[] { /* init the elements here or however you want to do it */ };
Collections.sort(data);
index = Arrays.binarySearch(data, value);

或者，如果不想对其进行排序，请执行线性搜索：

int index = -1; // not found

for(int i = 0; i < data.length; i++)
{
    if(data[i].equals(value))
    {
        index = i;
        break; // stop looking
    }
}

int索引=-1；//找不到
对于（int i=0；i

为完整起见，以下是完整方法的一些变化：

// strict one - disallow nulls for everything
public <T> static int linearSearch(final T[] data, final T value)
{
    int index;

    if(data == null)
    {
        throw new IllegalArgumentException("data cannot be null");
    }

    if(value == null)
    {
        throw new IllegalArgumentException("value cannot be null");
    }

    index = -1;

    for(int i = 0; i < data.length; i++)
    {
        if(data[i] == null)
        {
            throw new IllegalArgumentException("data[" + i + "] cannot be null");
        }

        if(data[i].equals(value))
        {
            index = i;
            break; // stop looking
        }
    }    

    return (index);
}

//严格的一-所有内容都不允许为空
公共静态整数线性搜索（最终T[]数据，最终T值）
{
整数指数；
如果（数据==null）
{
抛出新的IllegalArgumentException（“数据不能为空”）；
}
如果（值==null）
{
抛出新的IllegalArgumentException（“值不能为null”）；
}
指数=-1；
对于（int i=0；i

//允许一切为空

public static <T> int linearSearch(final T[] data, final T value)
{
    int index;

    index = -1;

    if(data != null)
    {
        for(int i = 0; i < data.length; i++)
        {
            if(value == null)
            {
                if(data[i] == null)
                {
                    index = i;
                    break;
                }
            } 
            else
            {            
                if(value.equals(data[i]))
                {
                    index = i;
                    break; // stop looking
                }
            }
        }    
    }

    return (index);
}

公共静态整数线性搜索（最终T[]数据，最终T值）
{
整数指数；
指数=-1；
如果（数据！=null）
{
对于（int i=0；i

您可以填写其他变体，如不允许空数据数组，或不允许值为空，或不允许数组为空。：-）

根据注释，这也与许可版本相同，并且由于您没有编写大部分代码，因此它比上面的版本要好。如果您希望它是偏执的，并且不允许对任何内容使用null，那么您就必须使用上面的偏执版本（这个版本基本上与另一个版本一样快，因为方法调用（asList）的开销在运行时可能会消失）

公共静态整数线性搜索（最终T[]数据，最终T值）
{
最终整数指数；
如果（数据==null）
{
指数=-1；
}
其他的
{
最后名单；
list=Arrays.asList（数据）；
index=list.indexOf（值）；
}
收益率（指数）；
}
正确回答您提出的问题。使用暴力
我希望这会有所帮助

   public int find(String first[], int start, int end, String searchString){
    int mid = start + (end-start)/2;
    // start = 0;
    if(first[mid].compareTo(searchString)==0){
        return mid;
    }
    if(first[mid].compareTo(searchString)> 0){
        return find(first, start, mid-1, searchString);
    }else if(first[mid].compareTo(searchString)< 0){
        return find(first, mid+1, end, searchString);
    }
    return -1;
  }

public int find（字符串优先[]，int开始，int结束，字符串搜索字符串）{
int mid=开始+（结束-开始）/2；
//开始=0；
如果（第一个[mid].compareTo（搜索字符串）==0）{
中途返回；
}
如果（第一个[mid]。比较（搜索字符串）>0）{
返回find（first、start、mid-1、searchString）；
}else if（第一个[mid]。比较到（搜索字符串）<0）{
返回find（first，mid+1，end，searchString）；
}
返回-1；
}
它不会返回正确的
   public int find(String first[], int start, int end, String searchString){
    int mid = start + (end-start)/2;
    // start = 0;
    if(first[mid].compareTo(searchString)==0){
        return mid;
    }
    if(first[mid].compareTo(searchString)> 0){
        return find(first, start, mid-1, searchString);
    }else if(first[mid].compareTo(searchString)< 0){
        return find(first, mid+1, end, searchString);
    }
    return -1;
  }