检查元素是否已在Java数组中

我现在正在进行的项目包括从文本文件中读取单词并将它们加载到数组中（最终是一个二叉树，但这将在稍后完成）。我必须将单词和单词的频率（最初为1）都加载到数组中，因此我将这两个变量打包到一个对象

WordNode

。我可以将单词加载到数组中，但是当我尝试检查数组中是否已经存在单词时，事情就会崩溃。如果是，我必须将频率增加1。但是，我的代码甚至没有检查单词，只是简单地添加了它（我假定它检查的是对变量的引用，而不是单词本身）。下面是我的

main

方法和

WordNode

类

主要方法：

public class Driver {
/////////////// fields ///////////////
public static ArrayUnorderedList<WordNode> wordArray = new ArrayUnorderedList<WordNode>();
public static LinkedBinarySearchTree<WordNode> wordTree = new LinkedBinarySearchTree<WordNode>();   //tree to hold words

/////////////// methods ///////////////
public static void main(String[] args) throws Exception {
    //ask for filename       
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    System.out.println("Enter the name of the file to read from: ");
    Reader file = new FileReader(reader.readLine());

    //read file
    Scanner input = new Scanner(file);

    while(input.hasNext()) {
        //get words from file
        String word = input.next();

        //remove non-word characters and convert to lowercase
        word = word.replaceAll("\\W", "");
        word = word.toLowerCase();

        //create node
        WordNode newWord = new WordNode(word);

        //if word is already in array
        if(wordArray.contains(newWord)) {
            System.out.println("Word is already in array");

            //increment frequency by 1
            int index = wordArray.find(newWord);
            wordArray.list[index].setFrequency(wordArray.list[index].getFrequency() + 1);
            System.out.println(newWord.getWord() + newWord.getFrequency());
        } else {
            System.out.println("Word is not yet in array");

            //add word to tree
            System.out.println(newWord.getWord());
            wordArray.addToRear(newWord);
        }
    }

    //insert into tree

    //perform traversals on tree
}

ArrayList类中的一些方法：

/**
* Returns true if this list contains the specified element.
* @param target the element that the list is searched for
* @return true if the target is in the list, false if otherwise 
*/
public boolean contains(T target) {
    return (find(target) != NOT_FOUND);
}

/**
* Returns the array index of the specified element, or the
* constant NOT_FOUND if it is not found.
* @param target the element that the list will be searched for
* @return the integer index into the array containing the target element, or the NOT_FOUND constant
*/
public int find(T target) {
    int scan = 0, result = NOT_FOUND;
    boolean found = false;

    if (!isEmpty()) {
       while (!found && scan < rear) {
          if (target.equals(list[scan])) {
              found = true;
          } else {
             scan++;
          }
       }
    }

    if (found) {
       result = scan;
    }

    return result;
}

/**
*如果此列表包含指定的元素，则返回true。
*@param target搜索列表的元素
*@如果目标在列表中，则返回true；否则返回false
*/
公共布尔包含（T目标）{
返回（查找（目标）！=未找到）；
}
/**
*返回指定元素的数组索引，或
*如果未找到常数，则未找到该常数。
*@param target将搜索列表的元素
*@将整数索引返回到包含目标元素的数组中，或返回NOT_FOUND常量
*/
公共整数查找（T目标）{
int scan=0，结果=未找到；
布尔值=false；
如果（！isEmpty（））{
同时（！找到并扫描<后）{
if（target.equals（list[scan]））{
发现=真；
}否则{
扫描++；
}
}
}
如果（找到）{
结果=扫描；
}
返回结果；
}

代码不起作用的直接原因是

ArrayUnorderedList#contains（）

可能依赖

equals（）

方法来确定条目是否在列表中。如果看不到类的定义，就不可能知道

由于您没有提供对

equals（）

的覆盖，它使用的是对象标识（对象

object

中的默认值），因此每个

WordNode

都与其他

WordNode

不同

如果要使用

ArrayUnorderedList

，则必须以正确的行为实现

WordNode#equals（）

---

但是，您应该考虑使用<代码> map < /C> >（或<代码> MAP>代码>，而不是存储这些频率。这会快得多。

代码不起作用的直接原因是

ArrayUnorderedList#contains（）

可能依赖

equals（）

方法来确定条目是否在列表中。如果看不到类的定义，就不可能知道

由于您没有提供对

equals（）

的覆盖，它使用的是对象标识（对象

object

中的默认值），因此每个

WordNode

都与其他

WordNode

不同

如果要使用

ArrayUnorderedList

，则必须以正确的行为实现

WordNode#equals（）

---

但是，您应该考虑使用<代码> map < /C> >（或<代码> MAP>代码>，而不是存储这些频率。这将快得多。

您需要覆盖WordNode中的eqauls：

public boolean equals(Object o) {
     if(o instanceof WordNode) {
        WordNode temp = (WordNode) o;
        return(temp.getWord().equals(this.word));
     }
     else
         System.out.println("Object o you passed is not a WordNode");
}

这样，如果两个不同的WordNode对象与word字段具有相同的字符串，则认为它们相等

如何称呼平等者：

WordNode n1 = new WordNode();
n1.setWord("test");

WordNode n2 = new WordNode();
n2.setWord("test");

System.out.println(n1.equals(n2));

---

因此equals接收object类型的对象，但当您在WordNode上调用equals时，您必须提供一个也是WordNode实例的对象，否则我所做的转换将失败（您的异常），当然，验证一个对象是否等于WordNode是没有意义的，您需要覆盖WordNode中的eqauls：

public boolean equals(Object o) {
     if(o instanceof WordNode) {
        WordNode temp = (WordNode) o;
        return(temp.getWord().equals(this.word));
     }
     else
         System.out.println("Object o you passed is not a WordNode");
}

这样，如果两个不同的WordNode对象与word字段具有相同的字符串，则认为它们相等

如何称呼平等者：

WordNode n1 = new WordNode();
n1.setWord("test");

WordNode n2 = new WordNode();
n2.setWord("test");

System.out.println(n1.equals(n2));

---

因此equals接收一个object类型的对象，但是当你在WordNode上调用equals时，你必须提供一个也是WordNode实例的对象，否则我所做的转换失败（你的例外），当然，验证一个对象是否等于WordNode是没有意义的，这就是我所想的（每个对象都是不同的，因此没有对单词进行比较），但我不确定如何进行比较，以便只对单词进行比较，并且可以更改相关对象。不幸的是，我不知道如何实现

WordNode#equals（）

因为我们班从未讨论过这一点。我也不知道映射是什么，尽管我不怀疑它会容易得多。相反，我知道如何实现equals方法，但我应该比较单词或其他值吗？另外，当我重写该方法时，我是否调用它而不是

contains（）

？或者我是否可以使

contains（）

使用我的新方法吗？

equals（）

的要点是比较对特定类重要的内容。在这种情况下，它可以只返回单词本身的

String#equals（）

结果。哦，您还应该实现

hashCode（）

同样，在本例中，返回

WordNode.word

的散列码。好的，我会试试。我现在应该使用我在其位置编写的

equals（）

方法，而不是使用

contains（）

，另外，我们的类还没有了解

hashCode（）

是什么，所以我认为我不能使用它。不，

contains（）

是

ArrayUnorderedList

上的方法，它将使用您对

equals（）

的覆盖来确定列表中是否已经包含该单词。您提供了

equals（）

方法（作为对

对象#equals（）的覆盖）

。根据定义，需要比较类的两个实例的任何其他类都将调用

对象#equals（…）

，它将被分派到equals方法，并为对象返回true或false。这就是我的想法