Question

对于包含这样句子的文件：

He O O
does O O
, O O
however O O
, O O
have B-MWE_LVC B-MWE_LVC_VERB
an I-MWE_LVC O
affair I-MWE_LVC B-MWE_LVC_NOUN
with O O
Clotho B-NE_PER O
, O O
the O O
youngest O O
aspect O O
of O O
Fate B-NE_MISC B-NE_MISC_SB
. O O

This O O
is O O
both O O
awkward O O
and O O
intriguing O O
to O O
Norton B-NE_PER O
since O O
her O O
past O O
is O O
his O O
future B-SENT_BOUND O
. O O

我想根据标记每个句子结尾的正则表达式（.o o）提取每个句子。我在下面写了一些代码来解析这个但是得到了一个错误

线程“main”中的异常java.lang.StringIndexOutOfBoundsException：字符串索引超出范围：-1。在java.lang.String.substring（未知来源）com.gyan.siapp.coref.resolve.test.main（test.java:46）

第46行是：builder.append（strLine.substring（0，strLine.indexOf（''）））;

我的代码：

    public static void main(String args[]) {
    StringBuilder builder = new StringBuilder();
    String  folderPath ="C:/Users/Desktop/Data_And_Sentences/wiki50.iob";

    Scanner file = null;
    try
    {
        file = new Scanner(new File(folderPath));
    }
    catch (FileNotFoundException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

        List<String> sentences = new ArrayList<String>();

        String strLine;

        //Read File Line By Line

   Pattern matchExp = Pattern.compile ("(.*?)(. O O)");
        Matcher m = matchExp.matcher(strLine);

        while (file.hasNext())   
        {

            while (!m.find()){
                builder.append(strLine.substring(0, strLine.indexOf(' ')));
                builder.append(" ");
            }

            sentences.add(builder.toString());

            }
            System.out.println(sentences);
           //return sentences;
    }

这是正确的做法吗？我应该使用除String Builder之外的其他结构来确保足够的内存吗？我的猜测是整个文件被读作一个字符串，因此我得到了这个例外。是吗？

Answer 1

首先，Scanner.next（）默认查找并返回下一个完整的标记除以＆＃34; ＆＃34; （空间）。因此，strLine将不包含任何空格，然后strLine.indexOf（＆＃39;＆＃39;）将返回-1并导致异常。您应该逐行读取文件到一个字符串。然后用你的模式拆分它们。 \ n

    StringBuilder input = new StringBuilder();
    while(file.hasNext()) {
        input.append(file.nextLine());
    }
    String[] sentences = input.toString().split("\\.* O O");

Answer 2

我不知道这是否会对你有所帮助。以下代码生成输出为 -

[他，他确实，他确实如此，但他确实如此，但是，他确实如此，但是，他确实如此，但是，他确实如此，但是，他确实如此，但他确实如此，然而，但是，他确实，然而，他确实，然而，他确实，然而，他确实，然而，他确实，然而，他与最年轻的人一样，然而，他确实与最年轻的一面，然而，他确实与但是，最年轻的一面，然而，他确实是最年轻的一面，然而，他确实是最年轻的一面。然而，他确实是最年轻的。然而，他确实是最年轻的。然而，他确实是，最年轻的。然而，他确实是，最年轻的。然而，这是两个，他确实是最年轻的。这是尴尬的，然而，他确实是最年轻的。这是尴尬的，然而，他确实是最年轻的。这既尴尬又有趣，但他确实是最年轻的。这既尴尬又有趣，但是，他确实是最年轻的。这既尴尬又有趣，但是，他确实是最年轻的。这既尴尬又令人感兴趣，因为他确实是最年轻的。这既尴尬又有趣，因为她，然而，他确实是最年轻的。从她过去开始，这既尴尬又有趣，但是，他确实是最年轻的。这既尴尬又有趣，因为她的过去是，然而，他确实是最年轻的。这既尴尬又有趣，因为她的过去是他的，然而，他确实是最年轻的。这既尴尬又有趣，因为她的过去是他的，然而，他确实是最年轻的。这既尴尬又有趣，因为她的过去是他的。 ]

<code>
  public static void main(String args[]) {
        StringBuilder builder = new StringBuilder();
        String  folderPath ="C:/Users/Desktop/Data_And_Sentences/wiki50.iob";

        Scanner file = null;
        try
        {
            file = new Scanner(new File(folderPath));
        }
        catch (FileNotFoundException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        List<String> sentences = new ArrayList<String>();

        String strLine;
        //String sentence = "";
        //Read File Line By Line
        Pattern matchExp = Pattern.compile ("\\.* O O");
        while (file.hasNext())   
        {

            strLine = file.nextLine();
            System.out.println(strLine);
            Matcher m = matchExp.matcher(strLine);
            if(m.find()) {
                System.out.println(strLine.substring(0, strLine.indexOf(" ")));
                builder.append(strLine.substring(0, strLine.indexOf(" ")));
                builder.append(" ");
            }
        }
        System.out.println(sentences);
        System.out.println(builder.toString());
        //return sentences;
    }
</code>

使用正则表达式从文件中解析多行句子

2 个答案: