Java 为任何类型的链表类编写remove（）方法

我从头开始为链表类编写

remove（）

方法时遇到一些问题

有两种

remove（）

我不确定哪一个坏掉了，我想这两个都是正确的，但是通过使用另一个测试文件运行我的类，
LinkedListTest
，我得到了关于
remove（）
方法的错误消息：

Running Test remove tests (6 tests)
Starting tests: ....EE
Time: 0.004

There were 2 failures:
1) t44RemoveFromThreeItemList1(LinkedListTest$RemoveTest)
java.lang.AssertionError: Wrong item removed from One ItemList expected:<y> but was:<x>
        at org.junit.Assert.fail(Assert.java:88)
        at org.junit.Assert.failNotEquals(Assert.java:743)
        at org.junit.Assert.assertEquals(Assert.java:118)
        ... 11 more
2) t45RemoveFromThreeItemList2(LinkedListTest$RemoveTest)
java.lang.AssertionError: Wrong item removed from One ItemList expected:<z> but was:<y>
        at org.junit.Assert.fail(Assert.java:88)
        at org.junit.Assert.failNotEquals(Assert.java:743)
        at org.junit.Assert.assertEquals(Assert.java:118)
        ... 11 more

Test Failed! (2 of 6 tests failed.)

Test failures: abandoning other phases.

运行测试删除测试（6个测试）
启动测试：……EE
时间：0.004
有两次失败：
1） t44RemoveFromThreeItemList1（LinkedListTest$RemoveTest）
java.lang.AssertionError:从一个项目列表中删除了错误的项目。应为：但为：
位于org.junit.Assert.fail（Assert.java:88）
位于org.junit.Assert.failNotEquals（Assert.java:743）
位于org.junit.Assert.assertEquals（Assert.java:118）
... 还有11个
2） t45RemoveFromThreeItemList2（LinkedListTest$RemoveTest）
java.lang.AssertionError:从一个项目列表中删除了错误的项目。应为：但为：
位于org.junit.Assert.fail（Assert.java:88）
位于org.junit.Assert.failNotEquals（Assert.java:743）
位于org.junit.Assert.assertEquals（Assert.java:118）
... 还有11个
测试失败！（6次测试中有2次失败。）
测试失败：放弃其他阶段。

任何建议都很感谢，我已经看了很长时间，需要一些新鲜的眼睛。这是我的密码：

import java.util.*;

public class LinkedList<E> {
   private class ListNode {
      E data;
      ListNode next;

      ListNode(E data) {
         this.data = data;
         next = null;
      }

      ListNode(E data, ListNode next) {
         this.data = data;
         this.next = next;
      }
   }


   private ListNode front;

   private int size;

   public LinkedList() {
      front = null;


   }  
   public int size() {
      return size;
   }
   public boolean isEmpty() {
      if (this.size == 0) {
         return true;
      } else {
         return false;
      }
   }
   public void add(E value) {
      this.size++;
      if (front == null) {
         front = new ListNode(value);
      } else {
         ListNode current = front;
         while (current.next != null) {
            current = current.next;
         }
         current.next = new ListNode(value);
      }
   }

   public void add(int index, E value) {
       if (index == 0){
             front = new ListNode(value, front);
         }  
       else {
              ListNode curr = front;
              for   (int i =    0;  i < index - 1;  i++){
                    curr = curr.next;
              }
              curr.next = new   ListNode(value, curr.next);
         }
    }


   public E get(int index) {
      ListNode current = front;

      for (int i = 0; i < this.size(); i++, current = current.next) {
         if (i == index) {
            return current.data;
         }

      }
      return current.data;

   }
   public E remove() {
      ListNode result = front;
      front = front.next;
      size--;
      return result.data;


   }


   public E remove(int index) {
      ListNode result;
      if (index < 0 || index >= this.size()) {
         throw new IndexOutOfBoundsException();

      }
      if    (index == 0){
          result = front;
             front =    front.next;
          size--;
          return result.data;

        } else {
             ListNode curr = front;
             for (int i = 1; i <    index; i++){
                curr = curr.next;
             }

          result = curr;
             curr.next = curr.next.next;

        }
      size--;
      return result.data;


    }

import java.util.*；
公共类链接列表{
私有类ListNode{
E数据；
listnodenext；
ListNode（E数据）{
这个数据=数据；
next=null；
}
ListNode（E数据，ListNode下一步）{
这个数据=数据；
this.next=next；
}
}
私有节点前端；
私有整数大小；
公共链接列表（）{
front=null；
}  
公共整数大小（）{
返回大小；
}
公共布尔值为空（）{
如果（this.size==0）{
返回true；
}否则{
返回false；
}
}
公共无效添加（E值）{
这个.size++；
if（front==null）{
front=新的ListNode（值）；
}否则{
ListNode当前=前端；
while（current.next！=null）{
当前=当前。下一步；
}
current.next=新列表节点（值）；
}
}
公共无效添加（整数索引，E值）{
如果（索引==0）{
front=新的ListNode（值，front）；
}  
否则{
ListNode curr=前端；
对于（int i=0；i=this.size（））{
抛出新的IndexOutOfBoundsException（）；
}
如果（索引==0）{
结果=前面；
front=front.next；
大小--；
返回结果数据；
}否则{
ListNode curr=前端；
对于（int i=1；i

此外，以下是测试文件的相关部分，用于上下文：

  public static class RemoveTest {   

      // Maximum 10 milliseconds for all tests
      @Rule public Timeout timeout = new Timeout(10);

      LinkedList<Character> oneList = null;
      LinkedList<Character> threeList = null;

      @Before public void setUp() {
         oneList = new LinkedList<Character>();
         oneList.add('a');
         threeList = new LinkedList<Character>();
         threeList.add('x');
         threeList.add('y');
         threeList.add('z');
      }

      @Test public void t41RemoveFromOneItemList() {
         assertEquals("Wrong item removed from One ItemList",
            new Character('a'), oneList.remove());
         assertEquals("zero element list is not empty.",
            true, oneList.isEmpty());
         assertEquals("zero element list has wrong size.",
            0, oneList.size());
      }

      @Test public void t42RemoveFromOneItemList() {
         assertEquals("Wrong item removed from One ItemList",
            new Character('a'), oneList.remove(0));
         assertEquals("zero element list is not empty.",
            true, oneList.isEmpty());
         assertEquals("zero element list has wrong size.",
            0, oneList.size());
      }

      @Test public void t42RemoveFromThreeItemList() {
         assertEquals("Wrong item removed from One ItemList",
            new Character('x'), threeList.remove());
         assertEquals("two element list is empty.",
            false, threeList.isEmpty());
         assertEquals("two element list has wrong size.",
            2, threeList.size());
         assertEquals("get(0) on two element list is wrong.",
            new Character('y'), threeList.get(0));
      }

      @Test public void t43RemoveFromThreeItemList0() {
         assertEquals("Wrong item removed from One ItemList",
            new Character('x'), threeList.remove(0));
         assertEquals("two element list is empty.",
            false, threeList.isEmpty());
         assertEquals("two element list has wrong size.",
            2, threeList.size());
         assertEquals("get(0) on two element list is wrong.",
            new Character('y'), threeList.get(0));
      }

      @Test public void t44RemoveFromThreeItemList1() {
         assertEquals("Wrong item removed from One ItemList",
            new Character('y'), threeList.remove(1));
         assertEquals("two element list is empty.",
            false, threeList.isEmpty());
         assertEquals("two element list has wrong size.",
            2, threeList.size());
         assertEquals("get(0) on two element list is wrong.",
            new Character('x'), threeList.get(0));
         assertEquals("get(1) on two element list is wrong.",
            new Character('z'), threeList.get(1));
      }

      @Test public void t45RemoveFromThreeItemList2() {
         assertEquals("Wrong item removed from One ItemList",
            new Character('z'), threeList.remove(2));
         assertEquals("two element list is empty.",
            false, threeList.isEmpty());
         assertEquals("two element list has wrong size.",
            2, threeList.size());
         assertEquals("get(1) on two element list is wrong.",
            new Character('y'), threeList.get(1));
      }
   }

公共静态类RemoveTest{
//所有测试的最大时间为10毫秒
@规则公共超时=新超时（10）；
LinkedList oneList=null；
LinkedList threeList=null；
@在公共作废设置（）之前{
oneList=newlinkedlist（）；
添加（'a'）；
threeList=新的LinkedList（）；
添加（'x'）；
三列表。添加（'y'）；
添加（'z'）；
}
@测试公共无效t41RemoveFromOneItemList（）{
assertEquals（“从一个项目列表中删除的项目错误”，
新字符（'a'），oneList.remove（））；
assertEquals（“零元素列表不为空。”，
true，oneList.isEmpty（）；
assertEquals（“零元素列表大小错误。”，
0，oneList.size（））；
}
@测试公共无效t42RemoveFromOneItemList（）{
assertEquals（“从一个项目列表中删除的项目错误”，
新字符（'a'），oneList.remove（0））；
assertEquals（“零元素列表不为空。”，
true，oneList.isEmpty（）；
assertEquals（“零元素列表大小错误。”，
0，oneList.size（））；
}
@测试公共无效t42RemoveFromThreeItemList（）{
assertEquals（“从一个项目列表中删除的项目错误”，
新字符（'x'），threeList.remove（））；
assertEquals（“两元素列表为空。”，
false，threeList.isEmpty（）；
assertEquals（“两元素列表的大小不正确。”，
2，threeList.size（））；
assertEquals（“两元素列表上的get（0）错误。”，
新字符（'y'），threeList.get（0））；
}
@测试公共无效t43RemoveFromThreeItemList0（）{
assertEquals（“从一个项目列表中删除的项目错误”，
新字符（'x'），三列表。删除（0））；
assertEquals（“两元素列表为空。”，
false，threeList.isEmpty（）；
assertEquals（“两元素列表的大小不正确。”，
2，threeList.size（））；
assertEquals（“两元素列表上的get（0）错误。”，
新字符（'y'），threeList.get（0））；
}
@测试公共无效t44RemoveFromThreeItemList1（）{
资产质量（“W
public E remove(int index) {
    ListNode result;
    if (index < 0 || index >= this.size()) {
        throw new IndexOutOfBoundsException();

    }
    ListNode curr = front;
    for (int i = 0; i < index; i++){
       curr = curr.next;
    }

    // front case added
    if(index == 0){
        front = curr.next;
    }

    result = curr;
    curr.next = curr.next.next;

    size--;
    return result.data;
}