Java 自定义列表类，如何循环hasNext方法？

大家好，我是java新手，非常感谢大家在这方面的帮助。 好的，问题是： 我有一个列表类和一个listNode类， list类由名称、firstNode和lastNode表示。 firstNode和lastNode来自类型listNode， listNode由一个对象（例如data或Object o）和一个nextNode表示，后者指向列表中的下一个节点，该节点也是listNode类型

列表类：

public class List {

private ListNode firstNode;
private ListNode lastNode;
private String name;

public List() {
    this("list");
}

public List(String listName) {
    name = listName;
    firstNode = lastNode = null;
}

public void insertAtFront(Object insertItem) {
    if (isEmpty())
        firstNode = lastNode = new ListNode(insertItem);
    else
        firstNode = new ListNode(insertItem, firstNode);
}

public void insertAtBack(Object insertItem) {
    if (isEmpty())
        firstNode = lastNode = new ListNode(insertItem);
    else
        lastNode = lastNode.nextNode = new ListNode(insertItem);
}

public Object removeFromFront() throws EmptyListException {
    if (isEmpty())
        throw new EmptyListException(name);
    Object removedItem = firstNode.data;

    if (firstNode == lastNode)
        firstNode = lastNode = null;
    else
        firstNode = firstNode.nextNode;
    return removedItem;
}

public Object removeFromBack() throws EmptyListException {
    if (isEmpty())
        throw new EmptyListException(name);

    Object removedItem = lastNode.data;
    if (firstNode == lastNode)
        firstNode = lastNode = null;
    else {
        ListNode current = firstNode;

        while (current.nextNode != lastNode)
            current = current.nextNode;

        lastNode = current;
        current.nextNode = null;
    }
    return removedItem;
}

public boolean isEmpty() {
    return firstNode == null;
}

public void print() {
    if (isEmpty()) {
        System.out.printf("Empty %s\n", name);
        return;
    }
    System.out.printf("The %s is : ", name);
    ListNode current = firstNode;

    while (current != null) {
        System.out.printf("%s", current.data);
        current = current.nextNode;
    }
    System.out.println("\n");
}

@Override
public String toString() {
    String stk = "(";
    if(isEmpty())return "Empty List";
    ListNode checkNode = firstNode;
        while (checkNode != null) {
        stk += checkNode.data.toString()+ " , ";
        checkNode = checkNode.nextNode;
    }
    return stk+")";
}
public ListNode removeAt (int k){
    if(k<=0 || k>getLength())
        try{
            throw new IllegalValues();
        }catch(IllegalValues iv){
            iv.printStackTrace();
            return null;
        }
    ListNode newNode = firstNode;
    if(k==1){
        newNode = firstNode;
        firstNode = firstNode.nextNode;
        return  newNode;
    }
    if(k==2){
        newNode = firstNode.nextNode;
        firstNode.nextNode = firstNode.nextNode.nextNode;
        return newNode;
    }

    if(k==3){
        newNode = firstNode.nextNode;
        firstNode.nextNode.nextNode = firstNode.nextNode.nextNode.nextNode;
        return newNode;
    }

    if(k==4){
        newNode = firstNode.nextNode;
        firstNode.nextNode.nextNode.nextNode = firstNode.nextNode.nextNode.nextNode.nextNode;
        return newNode;
    }

    return newNode;
}
public int getLength(){
    ListNode checkNode = firstNode;
    int count =0;
    while (checkNode != null) {
    count++;
    checkNode = checkNode.nextNode;
}
    return count;
}

}

这就是我正在使用的两个类我的问题是removeAt（）方法我不知道如何对它进行概括，并为所有代码（如for语句）生成一个通用的答案。我只能通过在if语句中分别编写每一个case来实现它。我需要编写一个for循环，以某种方式循环抛出hasNext（）方法。 有什么想法吗？？

---

提前感谢

为了删除

k

的第四个节点（当k>1时），您应该始终为一个节点执行以下操作：

someNode.nextNode = someNode.nextNode.nextNode;

这是位于要删除的节点之前的节点，使其成为

k-1

的第四个节点

可以找到具有for循环的节点：

if (k==1) {
    ListNode removedNode = firstNode;
    firstNode = firstNode.nextNode;
    return removedNode;
}
ListNode someNode = firstNode;
for (int i = 1; i < k - 1; i++) {
    someNode = someNode.nextNode;
}
ListNode removedNode = someNode.nextNode;
someNode.nextNode = someNode.nextNode.nextNode;
return removedNode;

if（k==1）{
ListNode removedNode=firstNode；
firstNode=firstNode.nextNode；
返回removedNode；
}
ListNode someNode=firstNode；
for（inti=1；i

---

请注意，k==1的情况是单独处理的。

好吧，为了删除

k

的第四个节点（当k>1时），始终有一个节点需要执行：

someNode.nextNode = someNode.nextNode.nextNode;

这是位于要删除的节点之前的节点，使其成为

k-1

的第四个节点

可以找到具有for循环的节点：

if (k==1) {
    ListNode removedNode = firstNode;
    firstNode = firstNode.nextNode;
    return removedNode;
}
ListNode someNode = firstNode;
for (int i = 1; i < k - 1; i++) {
    someNode = someNode.nextNode;
}
ListNode removedNode = someNode.nextNode;
someNode.nextNode = someNode.nextNode.nextNode;
return removedNode;

if（k==1）{
ListNode removedNode=firstNode；
firstNode=firstNode.nextNode；
返回removedNode；
}
ListNode someNode=firstNode；
for（inti=1；i

---

请注意，k==1的情况是单独处理的。

这里有一个变量使用0作为第一个索引：

public ListNode removeAt (int k)
{
  if (k < 0 || k >= getLength())
  {
    try
    {
        throw new IllegalValues();
    }
    catch(IllegalValues iv)
    {
        iv.printStackTrace();
        return null;
    }

    if (k == 0)
    {
      // first element should be removed
      removeFromFront();
    }
    else if (k == getLength() – 1)
    {
      // last element should be removed
      removeFromBack();
    }
    else
    {
      ListNode predecessor =  firstNode;
      for (int i = 0; i < k - 1; ++i)
      {
        predecessor = predecessor.nextNode;
      }

      ListNode removed = predecessor.nextNode;
      predecessor.nextNode = predecessor.nextNode.nextNode;
      return removed;
    }

public ListNode removeAt（int k）
{
如果（k<0 | | k>=getLength（））
{
尝试
{
抛出新的非法价值观（）；
}
捕获物（非法价值观四）
{
iv.printStackTrace（）；
返回null；
}
如果（k==0）
{
//第一个元素应该被删除
从前面移除（）；
}
else if（k==getLength（）–1）
{
//最后一个元素应该被删除
removeFromBack（）；
}
其他的
{
ListNode前置节点=第一个节点；
对于（int i=0；i

以下是一个使用0作为第一个索引的变体：

public ListNode removeAt (int k)
{
  if (k < 0 || k >= getLength())
  {
    try
    {
        throw new IllegalValues();
    }
    catch(IllegalValues iv)
    {
        iv.printStackTrace();
        return null;
    }

    if (k == 0)
    {
      // first element should be removed
      removeFromFront();
    }
    else if (k == getLength() – 1)
    {
      // last element should be removed
      removeFromBack();
    }
    else
    {
      ListNode predecessor =  firstNode;
      for (int i = 0; i < k - 1; ++i)
      {
        predecessor = predecessor.nextNode;
      }

      ListNode removed = predecessor.nextNode;
      predecessor.nextNode = predecessor.nextNode.nextNode;
      return removed;
    }

public ListNode removeAt（int k）
{
如果（k<0 | | k>=getLength（））
{
尝试
{
抛出新的非法价值观（）；
}
捕获物（非法价值观四）
{
iv.printStackTrace（）；
返回null；
}
如果（k==0）
{
//第一个元素应该被删除
从前面移除（）；
}
else if（k==getLength（）–1）
{
//最后一个元素应该被删除
removeFromBack（）；
}
其他的
{
ListNode前置节点=第一个节点；
对于（int i=0；i

确实要以1开始索引吗？在Java中，索引以0开始，因此列表实现可能会让人感到困惑。确实要以1开始索引吗？在Java中，索引以0开始，因此列表实现可能会让人感到困惑。