我正在编写一个应用了许多计算语言学原理的程序。我现在的问题是下面的一段代码构成了一个“灵活化两个定义”的方法。也就是说，它比较了同一个单词的两个不同定义，并且在每个定义中，将添加空或空格以便稍后使用更改的定义（添加空格）。 假设我们有以下两个定义，定义术语“自由落体”。
1) Free fall descent of a body subjected only to the action of gravity.
2) Free fall movement of a body in a gravitational field under the influence of gravity
有一个名为stoplist的单词列表，其中包含单词：“of”，“a”，“in”，“to”和“under”。在该过程之后，定义中也包含在停止列表中的每个单词必须对应于空白空间或另一个定义的另一个停止列表单词。因此，在执行此类过程之后，以两个不同列表表示的先前定义应如下所示：
1) Free fall descent of a body ____ ____ subjected only to the action of gravity.
2) Free fall movement of a body in a gravitational field under the influence of gravity.
我为实现此目的而编写的代码如下：
[...]
String[] sList = STOPLIST.split(" "); //this is the stoplist
String[] definition1 = defA1.split(" "); //this is the array of words of the first definition
String[] definition2 = defA2.split(" "); //this is the array of words of the second definition
List<String> def1 = new ArrayList<String>();
List<String> def2 = new ArrayList<String>();
List<String> stopList = new ArrayList<String>();
for(String word : definition1){
def1.add(word); //I transform arrays into lists this way because I used to think that using .asList() was the problem.
}
for(String word : definition2){
def2.add(word);
}
for(String word : sList){
stopList.add(word);
}
int mdef = (def1.size() <= def2.size()) ? def1.size() : def2.size(); //here mdef will have the value of the lenght of the shortest definition, and we are going to use the value of mdef to iterate later on.
for(int i = 0; i < mdef; i++){
if (stopList.contains(def1.get(i))) { //here I check if the first word of the first definition is also found in the stoplist.
if (!stopList.contains(def2.get(i))) { //If the word of def1 previously checked is in the stoplist, as well as the corresponding word in the second definition, then we won't add a " "(blank) space in the corresponding position of the second definition.
def2.add(i , " "); //here I add that blank space, only if the stoplist word in def1 corresponds to a non-stoplist word in def2. Again, we do this so the stoplist word in def1 corresponds to a blank space OR another stoplist word in def2.
if(mdef == def2.size())
mdef++; //In case the shortest definition is the definition to which we just added spaces, we increment mdef++, because that space added increases the length of the shortest definition, and to iterate in this recenlty extended definiton, we have to increment the index with which we iterate.
}
} else if (stopList.contains(def2.get(i))) { //this else if does the same than the previous one, but checks for the second definition instead of the first one. And adds blanks to def1 instead of def2 if necessary.
if (!stopList.contains(def1.get(i))) {
def1.add(i , " ");
if(mdef == def1.size())
mdef++;
}
}
}
[...]
现在，如果你仔细分析代码，你会发现不会检查最长列表中的所有单词，因为我们使用最短定义的长度作为索引来迭代定义。这很好，不必检查最长定义的剩余单词，它们将对应于另一个定义的空格（如果列表在添加空格后最终没有相同的长度，正如前面的例子所示。）
现在，在解释之后，问题如下：在运行主类（调用包含前面代码的方法）之后，弹出运行时异常：
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 0
at java.util.ArrayList.rangeCheck(ArrayList.java:571)
at java.util.ArrayList.get(ArrayList.java:349)
at main2.main(main2.java:75)
我不明白为什么它发现任何列表为“空”。我试图以太多方式解决它，我希望我给出了一个很好的解释。
如果我将mdef分配给最长的大小而不是最短的大小，那么这可能有助于提示：
int mdef = (def1.size() >= def2.size()) ? def1.size() : def2.size();
错误更改为：
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 15, Size: 15
at java.util.ArrayList.rangeCheck(ArrayList.java:571)
at java.util.ArrayList.get(ArrayList.java:349)
at asmethods.lcc.turnIntoFlex(lcc.java:55)
at asmethods.lcc.calLcc(lcc.java:99)
at main2.main(main2.java:73)'
其中lcc是包含方法turnIntoFlex的类，其中包含我正在显示的代码段。 “turnIntoFlex”的第55行对应于循环的第一行，即：
if (stopList.contains(def1.get(i))) { [...]
注释：defA1和defA2的值分别是定义。即，def1和def2最初是列表，其中每个单独的元素是一个单词。我无法通过打印来检查是否正在填充这些列表，因为indexoutofboundsexception在循环开始时弹出。但是，我打印mdef，def1.size（）和def2.size（）的大小的值，并且值变为13或15，表明在“for”循环开始之前没有列表为空
mdef ++是我最近添加的，不是为了解决这个特定的问题，但是在添加mdef ++部分之前错误已经突然出现。正如我解释的那样，目的是在扩展最短列表时增加mdef ++（但只有在扩展短列表时才这样），所以我们遍历短列表中的所有单词，而不是更多。
答案 0 :(得分：0)
您的代码存在的一个问题是，当您递增mdef时，您不会检查 now 是否超过其他列表的长度。< / p>
例如，假设def1有3个单词而def2有4个单词。 mdef将从3开始。但是假设您连续向def1添加两个空格并将mdef增加两次为5.现在超过def2的长度，然后如果您继续迭代到5，则导致def2 else条件中的索引超出范围异常。
稍后添加：
您的代码的另一个严重问题（我后面想到的）是当您将空间添加到列表（def1或def2）时，这会移动所有后续元素的索引因此，例如，如果在def1为{0}时在i中的地点0处添加空格，则在下一次通过循环时，将i增加到1 ，你会看到你在前一个传球中看到的def1中的同一个词。这可能是你的一些异常的来源（因为它会导致一个连续的循环，直到你超过另一个列表的长度：上面的问题＃1）。
要纠正这两个问题，您需要将代码更改为：
int i = 0;
int j = 0;
while (i < def1.size() && j < def2.size()) {
if (stopList.contains(def1.get(i)) && !stopList.contains(def2.get(j)))
def2.add(j++, " ");
else if (stopList.contains(def2.get(j)) && !stopList.contains(def1.get(i)))
def1.add(i++, " ");
++i;
++j;
}
请注意，您在此实现中不再需要mdef。
答案 1 :(得分：0)
伙计，我想我明白了。我修改了代码，但我希望你能理解我的所作所为：
static public void main(String[] argv) {
String[] sList = "of a in to under".split(" ");
String[] definition1 = "Free fall descent of a body subjected only to the action of gravity"
.split(" ");
String[] definition2 = "Free fall movement of a body in a gravitational field under the influence of gravity"
.split(" ");
List<String> def1 = new ArrayList<String>();
List<String> def2 = new ArrayList<String>();
List<String> stopList = new ArrayList<String>();
for (String word : definition1) {
def1.add(word);
}
for (String word : definition2) {
def2.add(word);
}
for (String word : sList) {
stopList.add(word);
}
int mdef = (def1.size() <= def2.size()) ? def1.size() : def2.size(); // Shortest
// length
for (int i = 0; i < mdef; i++) {
System.out.println(i);
if (!stopList.contains(def1.get(i)) && !stopList.contains(def2.get(i))) {
continue;
}
else if (stopList.contains(def1.get(i)) && stopList.contains(def2.get(i))) {
continue;
}
else if (!stopList.contains(def1.get(i)) && stopList.contains(def2.get(i))) {
def1.add(i, " ");
mdef = (def1.size() <= def2.size()) ? def1.size() : def2.size(); // define mdef again
}
else if (stopList.contains(def1.get(i)) && !stopList.contains(def2.get(i))) {
def2.add(i, " ");
mdef = (def1.size() <= def2.size()) ? def1.size() : def2.size(); // define mdef again
}
}
for (String word : def1) {
if (word.equals(" "))
System.out.print("_ ");
else
System.out.print(word+" ");
}
System.out.println();
for (String word : def2) {
if (word.equals(" "))
System.out.print("_ ");
else
System.out.print(word+" ");
}
}
答案 2 :(得分：-2)
这是您正在使用的确切代码吗？我刚刚运行它并且工作正常，我用过：
import java.util.*;
public class HelloWorld {
public static void main(String []args) {
String stoplist= "of a in to and under";
String defA1 = "Free fall descent of a body subjected only to the action of gravity";
String defA2 = "Free fall movement of a body in a gravitational field under the influence of gravity";
String[] sList = stoplist.split(" "); //this is the stoplist
String[] definition1 = defA1.split(" "); //this is the array of words of the first definition
String[] definition2 = defA2.split(" "); //this is the array of words of the second definition
List<String> def1 = new ArrayList<String>();
List<String> def2 = new ArrayList<String>();
List<String> stopList = new ArrayList<String>();
for (String word : definition1) {
def1.add(word); //I transform arrays into lists this way because I used to think that using .asList() was the problem.
}
for (String word : definition2) {
def2.add(word);
}
for (String word : sList) {
stopList.add(word);
}
int mdef = (def1.size() <= def2.size()) ? def1.size() : def2.size(); //here mdef will have the value of the lenght of the shortest definition, and we are going to use the value of mdef to iterate later on.
for (int i = 0; i < mdef; i++) {
if (stopList.contains(def1.get(i))) { //here I check if the first word of the first definition is also found in the stoplist.
if (!stopList.contains(def2.get(i))) { //If the word of def1 previously checked is in the stoplist, as well as the corresponding word in the second definition, then we won't add a " "(blank) space in the corresponding position of the second definition.
def2.add(i , " "); //here I add that blank space, only if the stoplist word in def1 corresponds to a non-stoplist word in def2. Again, we do this so the stoplist word in def1 corresponds to a blank space OR another stoplist word in def2.
if (mdef == def2.size())
mdef++; //In case the shortest definition is the definition to which we just added spaces, we increment mdef++, because that space added increases the length of the shortest definition, and to iterate in this recenlty extended definiton, we have to increment the index with which we iterate.
}
} else if (stopList.contains(def2.get(i))) { //this else if does the same than the previous one, but checks for the second definition instead of the first one. And adds blanks to def1 instead of def2 if necessary.
if (!stopList.contains(def1.get(i))) {
def1.add(i , " ");
if (mdef == def1.size())
mdef++;
}
}
}
for (String word : def1) {
System.out.print(word+",");
}
System.out.println();
for (String word : def2) {
System.out.print(word+",");
}
}
}