單鏈表節點無法轉換為整數

Question

我正在寫一個通用的單鏈表作為家庭作業。 我已經獲得了講師將用來測試代碼的 JUnit 測試。 當我運行測試時，給了我這個錯誤：java.lang.ClassCastException: SinglyLinkedList$Node cannot be cast to java.lang.Integer。 如果我使用泛型作為類型，為什么我不能將其轉換為整數？

此外，當我第一次運行測試時，bash 顯示： JUnit 版本 4.12 .EEE 在我結束這個過程之前它一直保持這樣。 我認為這可能是無限循環的跡象，但即使查看我的代碼，我也找不到它在哪里無限。

這是我的 SinglyLinkedList 類

import java.util.Iterator;
import java.util.NoSuchElementException;

public class SinglyLinkedList<E> implements Iterable<E>{

    private Node<E> head;
    private Node<E> tail;

    public SinglyLinkedList() {
        head = new Node<E>(null, tail);
        tail = new Node<E>(null, null);
    }

    /**
     * Insert at the end of the list
     * @param E
     */
    public void add(E element) {
        Node<E> place = head;
        if(head.getNext() == null){
            Node node = new Node(element,tail);
            head.setNext(node);
        }
        else{while(place.next != tail){
            place = place.getNext();
            Node node = new Node(element, tail);
            place.setNext(node);
            }
        }
    }

    /**
     * Remove element from the list
     * @param E
     */
    public void remove(E element){
        Node place = head;
        Node prev = head;
        while(place.getElement() != element){
            prev = place;
            place = place.getNext();
        }
        prev.setNext(place.getNext());
    }

    /**
     * Clear all elements
     */
    public void clear(){
        head.setNext(null);
    }

    /**
     * Gets the Nth to last node
     * @param int n
     * @return E
     */
    public E getNthToLast(int n){
        int length = 0;
        Node temp = head;
        while(temp.getNext() != tail){
            temp = temp.getNext();
            length++;
        }
        if(length < n){
            throw new NoSuchElementException();
        }
        temp = head;
        for(int i = 0; i < length - n+1; i++){
            temp = temp.getNext();
        }
        return (E) temp.getElement();
    }
    /**
     * Creates new Iterator
     * @return SinglyLinkedListIterator
     */
    @Override
    public SinglyLinkedListIterator iterator(){
        return new SinglyLinkedListIterator();
    }

    private class Node<E> {
        private E element;
        private Node<E> next;

        public Node(E element, Node next) {
            this.element = element;
            this.next = next;
        }

        public void setNext(Node next){
            this.next = next;
        }
        public Node getNext(){
            return this.next;
        }
        public void setElement(E element){
            this.element = element;
        }
        public E getElement(){
            return this.element;
        }

    }

    public class SinglyLinkedListIterator implements Iterator<E> {
        private Node curr = head;
        Node prev = head;

        /**
         * Gets the next node 
         * @return E
         */
        @Override
        public E next() {
            if(curr.getNext() != tail){
                prev = curr;
                curr = curr.getNext();
                return (E) curr;
            }
            else{
                throw new NoSuchElementException();
            }
        }
        @Override
        public boolean hasNext() { 
            if(curr.getNext() != null){
                return true;
            }
            else{return false;}
        }
        @Override
        public void remove() {
            if(curr != tail){
                prev.setNext(curr.getNext());
            }else{throw new IllegalStateException();}
        }
        public void add(E element){
            Node node = new Node(element, curr.getNext());
            curr.setNext(node);
        }
    }
}

這是 JUnit 測試：

import java.util.Iterator;
import java.util.NoSuchElementException;

import static org.junit.Assert.*;
import org.junit.Test;
import org.junit.Before;
import org.junit.Rule;
import org.junit.rules.ExpectedException;

public class TestLinkedList{
  private SinglyLinkedList<Integer> list;

  @Rule // this rule allows one of the tests to verify that an exception is thrown
  public ExpectedException thrown = ExpectedException.none();

  @Before
  public void setUp(){
    list = new SinglyLinkedList<>();
    SinglyLinkedList<Integer>.SinglyLinkedListIterator it = list.iterator();
    for(int i = 9; i > 0; i--){
      it.add(new Integer(i));
      it.next();
    }
    // Question to all: The process of adding numbers to the list could
    // have been simplified by dispensing with the iterator and simply
    // calling SinglyLinkedList's add() method. Why use the iterator?
    // What benefit does it provide over SinglyLinkedList's add?
  }

  /**
  * Ensure that the linked list holds the expected values after the
  * initialization in the setup() method. This initialization used the
  * list iterator to perform the adds.
  */
  @Test
  public void testIteratorAdd(){
    Iterator<Integer> it = list.iterator();
    Integer listElement;
    for(int i = 9; i > 0; i--){
      listElement = it.next();
      assertEquals(i, listElement.intValue());
    }
  }

  /**
  * Ensure that the list is built correctly if the list's add method is
  * used instead of the iterator's add method.
  */
  @Test
  public void testListAdd(){
    list.clear();
    for(int i = 9; i > 0; i--){
      list.add(new Integer(i));
    }
    Iterator<Integer> it = list.iterator();
    Integer listElement;
    for(int i = 9; i > 0; i--){
      listElement = it.next();
      assertEquals(i, listElement.intValue());
    }
  }

  /**
  * Remove all the odd numbers using the list's remove method and ensure
  * that the remaining elements are as expected (the even numbers 8, 6,
  * 4, and 2).
  */
  @Test
  public void testListRemove(){
    list.remove(9);
    list.remove(7);
    list.remove(5);
    list.remove(3);
    list.remove(1);

    Iterator<Integer> it = list.iterator();
    int evenNum = 8;
    while(it.hasNext()){
      assertEquals(evenNum,it.next().intValue());
      evenNum = evenNum - 2;
    }
  }

  /**
  * Remove all the even numbers using the iterators's remove method and ensure
  * that the remaining elements are as expected (the odd numbers 9, 7,
  * 5, 3, and 1).
  */
  @Test
  public void testIteratorRemove(){
    // first, remove all the even numbers
    Iterator<Integer> it = list.iterator();
    while(it.hasNext()){
      Integer theVal = it.next().intValue();
      if( theVal.intValue() % 2 == 0){
        it.remove();
      }
    }
    // Next, check that the list contains the correct
    // remaining numbers
    it = list.iterator();
    int oddNum = 9;
    while(it.hasNext()){
      assertEquals(oddNum,it.next().intValue());
      oddNum = oddNum - 2;
    }
  }

  /**
  * Attempt to remove from an empty list and ensure that the
  * IllegalStateException is thrown
  */
  @Test
  public void testEmptyRemove(){
    list.clear();
    thrown.expect(IllegalStateException.class);
    Iterator<Integer> it = list.iterator();
    it.remove();
  }

  /**
  * Attempt to call next() when already at the end of the list and
  * ensure that the NoSuchElementException is thrown.
  */
  @Test
  public void testInvalidNext(){
    list.clear();
    thrown.expect(NoSuchElementException.class);
    Iterator<Integer> it = list.iterator();
    it.next();
  }

  /**
  * Test the getNthToLast method. 
  *
  * As an example, given the numbers that is list holds:
  * 9 8 7 6 5 4 3 2 1
  * the 2nd to last element is 2, the 3rd to last
  * is 3, and so on.
  *
  * Ensure that the getNthToLast returns 4 when requested the 4th to
  * last element.
  */
  @Test
  public void testGetNthToLast(){
    Integer ans = list.getNthToLast(4);
    assertEquals(new Integer(4),ans);
  }
}

Answer 1

代碼清理

您有很多原始類型，這使查找損壞的代碼變得復雜，您想明確地說Node是Node<E> 。

主要問題

return (E) curr;

您正在返回節點並嘗試對其進行強制轉換，導致出現問題，應該是：

return curr.element;