-1
Je suis en train d'écrire une liste générique à lien unique comme devoir. J'ai reçu le test JUnit que l'instructeur va utiliser pour tester le code. Lorsque j'exécute le test, me donne cette erreur: java.lang.ClassCastException: SinglyLinkedList $ Le noeud ne peut pas être converti en java.lang.Integer. Si j'utilise un générique comme type, pourquoi ne puis-je pas le convertir en entier?Le noeud de la liste à liaison unique ne peut pas être converti en entier
De même, lorsque j'ai effectué le test pour la première fois, le bash montrait: JUnit version 4.12 .E.E.E. Et c'est resté comme ça jusqu'à la fin du processus. Je pense que cela peut être un signe d'une boucle infinie, mais même en regardant mon code, je ne peux pas trouver où il serait infini.
Ceci est ma classe 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);
}
}
}
C'est le test 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);
}
}
Vous essayez de lancer le nœud lui-même, mais vous devriez être lancer l'élément du nœud –