Java Class Cast Exception

Question

The project I am working on right now involves me reading words from a text file and loading them into an array (and eventually a binary tree, but that will be finished later). I must load both the word and the word's frequency (initially 1) into the array, so I have packed both variables into an object WordNode. I am able to load the words into the array, but things fall apart when I try to check if a word is already in the array. If it is, I must increase the frequency by 1. I have written a new equals() method to override the default method, so that words are compared rather than variable references. However, I am now getting the error Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [LWordNode;. Why is this coming up? I thought only WordNode objects were being passed to equals().

Main method:

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.getFrequency() + ") " + newWord.getWord());
        } else {
            System.out.println("Word is not yet in array");

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

    //insert into tree

    //perform traversals on tree
}

WordNode class:

public class WordNode {
   protected String word;
   protected WordNode left, right;
   protected int frequency;

   /**
    * Creates a new node with the specified data.
    * @param obj the element that will become a part of the new node
    */
   WordNode(String obj) {
      word = obj;
      left = null;
      right = null;
      frequency = 1;
   }

   /**
    * Method to check for string equivalence.
    * @return true if words are the same
    */
   public boolean equals(Object obj) {
       WordNode tempWord = (WordNode)obj;
       return(tempWord.getWord().equals(this.word));
   }

   /**
    * Gets the word.
    * @return the word
    */
   public String getWord() {
      return word;
   }

   /**
    * Sets the word.
    * @param word the word to set
    */
   public void setWord(String word) {
      this.word = word;
   }

   /**
    * Gets the left.
    * @return the left
    */
   public WordNode getLeft() {
      return left;
   }

   /**
    * Sets the left.
    * @param left the left to set
    */
   public void setLeft(WordNode left) {
      this.left = left;
   }

   /**
    * Gets the right.
    * @return the right
    */
   public WordNode getRight() {
      return right;
   }

   /**
    * Sets the right.
    * @param right the right to set
    */
   public void setRight(WordNode right) {
      this.right = right;
   }

   /**
    * Gets the frequency.
    * @return the frequency
    */
   public int getFrequency() {
      return frequency;
   }

   /**
    * Sets the frequency.
    * @param frequency the frequency to set
    */
   public void setFrequency(int frequency) {
      this.frequency = frequency;
   }
}

Some methods from the ArrayList class:

/**
* 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;
}

Answer 1

One possible cause is your equals method:

public boolean equals(Object obj) {
    //You need to check that obj is a WordNode
    //For example: if (obj instanceof WordNode) {...
    WordNode tempWord = (WordNode)obj; 
    return(tempWord.getWord().equals(this.word));
}

will throw an exception if obj is not a WordNode.

You should have a look at this discussion about how one should override equals and hashcode in Java.

Answer 2

When you use Generics, Java erases the type information and performs casts at runtime. This means that if any part of your code contains T[], it is compiled as Object[] instead.

Based on the references to wordArray.list[index].setFrequency() and wordArray.list[index].getFrequency(), it looks like you used T[] as the type for the list field of ArrayUnorderedList. This is not a correct use of Generics. Java will attempt to cast the Object[] list to WordNode[] before accessing the array's index. Casting one array type to another array type will always produce a ClassCastException.

Instead of accessing the list field directly, consider implementing a public T get(int index) method in ArrayUnorderedList. The use of the generic type T in the method signature is the proper way to implement object access in a generic collection. Here, the implicit cast occurs after the array access.

Alternately, consider using the java.util.ArrayList or java.util.HashSet classes instead. Both are generic collections.

Answer 3

don't except the equals method should be call with always a WordNode parameter.

You have to verify the type of the parameter object

public boolean equals(Object obj) {
   if(!(obj instanceof WordNone)){
     return false;
   }
   // rest of equals method
}

Answer 4

It's never safe to assume that what is passed in the equals will always be an instance of the same object. You need to do some check like

public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (getClass() != obj.getClass()) {
        return false;
    }
    WordNode otherWord = (WordNode) obj;

    return(otherWord.getWord().equals(this.word));
}

Anyway, why don't you use a Set instead? It's the best data structure that you can use for your case.

Answer 5

Since you only care about a word and its frequency why aren't you using a Map or a Set instead? The Key would be the word and the value the frequency. That way you simply call Map.contains(word) and you see if its already in and then do whatever you want to do with it.