Java 二进制搜索出错&；合并排序功能（带有IO和命令行）

我遇到了一个错误。运行此程序需要在命令行中引用已编译的jar文件，以指定必须在输入文件中找到的目标

发生的错误是命令行中指定的任何目标字符串（存在于输入文件中）在输出“在第{lineNumber}行上找到”时获得“未找到”的输出

我通读了整个课程，坦率地说，我完全不知道这个错误发生在哪里

感谢您的帮助

主要类别：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Search {

public static void main(String[] args) throws FileNotFoundException {
    Scanner in = null;
    int index = 0;
    String[] word = null;
    int[] lineNumber = null;

    // check number of command line arguments is at least 2
    if (args.length < 2) {
        System.out.println("Usage: Search <input file> <target1> [target2...]");
        System.exit(1);
    }

    // initialize Scanner
    in = new Scanner(new File(args[0]));

    // matches the end of a file character
    in.useDelimiter("\\Z");

    // puts entire file into one string
    String temp = in.next();

    in.close();

    // intialize arrays & plug elements in
    word = temp.split("\n");
    lineNumber = new int[word.length];
    populate(lineNumber);

    // sort String array
    mergeSort(word, lineNumber, 0, word.length - 1);

    // if multiple targets exist
    if (args.length > 2) {
        for (int i = 1; i < args.length; i++) {
            index = binarySearch(word, 0, word.length - 1, args[i]);
            if (index < 0) {
                System.out.println(args[i] + " not found");
            } else {
                System.out.println(args[i] + " found on line " + lineNumber[index]);
            }
        }

        // if only single target specified in command line
    } else {
        index = binarySearch(word, 0, word.length - 1, args[1]);
        if (index < 0) {
            System.out.println(args[1] + " not found");
        } else {
            System.out.println(args[1] + " found on line " + lineNumber[index]);
        }
    }
}

// recursively halves arrays then plugs into merge function
public static void mergeSort(String[] word, int[] lineNumber, int p, int r) {
    int q;

    if (p < r) {
        // q is midpoint
        q = (p + r) / 2;

        // recursive stuff
        mergeSort(word, lineNumber, p, q);
        mergeSort(word, lineNumber, q + 1, r);

        // merge arrays
        merge(word, lineNumber, p, q, r);

    }
}

// merges sorted String arrays into one large sorted String array
public static void merge(String[] word, int[] lineNumber, int p, int q, int r) {
    // element ranges
    int n1 = q - p + 1;
    int n2 = r - q;

    // half String arrays to be merged
    String[] L = new String[n1];
    String[] R = new String[n2];

    // half int arrays to be merged
    int[] iL = new int[n1];
    int[] iR = new int[n2];

    // array indexes (for looping)
    int i, j, k;

    // plugging specific elements into new array
    for (i = 0; i < n1; i++) {
        L[i] = word[p + i];
        iL[i] = lineNumber[p + i];
    }

    // plugging specific elements into new array
    for (j = 0; j < n2; j++) {
        R[j] = word[q + j + 1];
        iR[j] = lineNumber[q + j + 1];
    }

    // reset array indexes
    i = 0;
    j = 0;

    // loop through entirety of elements
    for (k = p; k <= r; k++) {
        // if both arrays still have unmerged element(s)
        if (i < n1 && j < n2) {
            // if left array's element precedes right's element
            // lexicographically
            if (L[i].compareTo(R[j]) < 0) {
                word[k] = L[i];
                lineNumber[k] = iL[i];
                i++;
            } else { // if right's element precedes (or the words are equal)
                word[k] = R[j];
                lineNumber[k] = iR[j];
                j++;
            }
            // if only left array has unmerged element(s)
        } else if (i < n1) {
            word[k] = L[i];
            lineNumber[k] = iL[i];
            i++;
            // if only right array has unmerged element(s)
        } else {
            word[k] = R[j];
            lineNumber[k] = iR[j];
            j++;
        }
    }

}

// searches sorted String array and returns index of target (or -1 if not
// found)
public static int binarySearch(String[] word, int p, int r, String target) {
    int q;
    if (p > r) {
        return -1;
    } else {
        q = (p + r) / 2;
        if (target == word[q]) {
            return q;
        } else if (target.compareTo(word[q]) < 0) {
            return binarySearch(word, p, q - 1, target);
        } else {
            return binarySearch(word, q + 1, r, target);
        }
    }
}

// helper method: plugs numbers (in order) into an int array
public static void populate(int[] array) {
    for (int i = 0; i < array.length; i++) {
        array[i] = i + 1;
    }
}
}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.Scanner；
公共类搜索{
公共静态void main（字符串[]args）引发FileNotFoundException{
扫描仪输入=空；
int指数=0；
字符串[]字=null；
int[]lineNumber=null；
//检查命令行参数的数量是否至少为2
如果（参数长度<2）{
System.out.println（“用法：搜索[target2…]”）；
系统出口（1）；
}
//初始化扫描仪
in=新扫描仪（新文件（args[0]）；
//匹配文件字符的结尾
in.useDelimiter（“\\Z”）；
//将整个文件放入一个字符串中
字符串temp=in.next（）；
in.close（）；
//初始化数组并插入元素
word=临时拆分（“\n”）；
lineNumber=新整数[字长]；
填充（行号）；
//排序字符串数组
合并排序（字，行号，0，字长度-1）；
//如果存在多个目标
如果（参数长度>2）{
对于（int i=1；i对于（k=p；k您需要更改下面的方法。
String
应与
equals（）
方法进行比较，并使用
trim（）
方法避免尾随空格

public static int binarySearch(String[] word, int p, int r, String target) {
    int q;
    if (p > r) {
        return -1;
    } else {
        q = (p + r) / 2;
        if (target.trim().equals(word[q].trim())) {
            return q;
        } else if (target.compareTo(word[q]) < 0) {
            return binarySearch(word, p, q - 1, target);
        } else {
            return binarySearch(word, q + 1, r, target);
        }
    }
}

publicstaticintbinarysearch（String[]word，intp，intr，stringtarget）{
int-q；
如果（p>r）{
返回-1；
}否则{
q=（p+r）/2；
if（target.trim（）.equals（word[q].trim（）））{
返回q；
}else if（target.compareTo（word[q]）<0）{
返回二进制搜索（word、p、q-1、target）；
}否则{
返回二进制搜索（word、q+1、r、target）；
}
}
}
您必须首先隔离错误，调试器可以帮助您完成此操作。顺便说一句，您应该在来到这里之前完成此操作，如果仍然卡住，请说明您为调试代码所做的工作，以及为什么它没有帮到您。祝您好运。非常感谢您，我没有发现那个愚蠢的错误。