Java 我的LinkedList的size（）有什么问题吗？

我需要有关自定义链接列表的帮助，我无法解决问题。我需要一些帮助。 以下是我的size（）方法：

我总是弄错尺码，但我没能找出问题所在

以下是我在主方法中的代码：

 list = new ObjectLinkedList();
    m1 = new Money(5, (byte) 6);
    node1 = new Node(m1);
    list.add(0, node1);
    m2 = new Money(2, (byte) 4);
    node2 = new Node(m2);
    list.add(1, node2);
   System.out.println(list.Size());

---

我一直得到1而不是2

将

大小

字段添加到

对象链接列表中

：

private int size;

在添加新项目之前在行中递增，在从列表中删除项目之前在行中递减

然后添加一个方法：

public int getSize() {
  return this.size;
}

由于OP请求后递归方法（这是低效的！）：

定位错误 错误存在于

add（int，Object）

方法中，更准确地说，存在于以下构造中：

for (int i = 1; i <= index; i++) {
    tempNode = tempNode.getNext();
    if (i == index - 1) {
        if (index != size() - 1) {
            currentNode.setNext(tempNode.getNext());
        } else {
            currentNode.setNext(null);
        }
        tempNode.setNext(currentNode);
    }
}

旁注 您的列表已经在

节点

s中包装了对象，因此无需在

main

方法中进行此操作。因此

list = new ObjectLinkedList();
m1 = new Money(5, (byte) 6);
node1 = new Node(m1);
list.add(0, node1);
m2 = new Money(2, (byte) 4);
node2 = new Node(m2);
list.add(1, node2);
System.out.println(list.size());

你应该会写作

list = new ObjectLinkeList();
m1 = new Money(5, (byte) 6);
list.add(m1);
m2 = new Money(2, (byte) 4);
list.add(m2);
System.out.println(list.size());

或者只是

list = new ObjectLinkeList();
list.add(new Money(5, (byte) 6));
list.add(new Money(2, (byte) 4));
System.out.println(list.size());

---

获取链表的大小就是遍历它。下面我提供了三个遍历链表的选项：for循环、while循环和递归

class ObjectLinkedList<T> {

  public static void main(String... args) {
    final ObjectLinkedList<String> list = new ObjectLinkedList<>();
    list.add(0, "World");
    list.add(0, "Hello");
    list.add(2, "!");
    System.out.println(list);
    System.out.println(list.size());
  }

  private Node<T> firstNode = null;

  public void add(int index, T obj) {
    final Node<T> newNode = new Node<>(obj);
    Node<T> tempNode = firstNode;
    if (index == 0) {
      firstNode = newNode;
      firstNode.setNext(tempNode);
      return;
    } else {
      int count = 0;
      //option 1: a for loop
      for (Node<T> current = firstNode; current != null; current = current.getNext()) {
        tempNode = current.getNext();
        if (++count == index) {
          current.setNext(newNode);
          newNode.setNext(tempNode);
          return;
        }
      }
    }
    throw new IndexOutOfBoundsException("Out of bounds!");
  }

  public String toString() {
    Node<T> tmp = firstNode;
    StringBuilder res = new StringBuilder("ObjectLinkedList: [");
    //option 2: a while loop
    while (tmp != null) {
      res.append(tmp);
      tmp = tmp.getNext();
      if (tmp != null) {
        res.append(", ");
      }
    }
    return res.append("]").toString();
  }

  public int size() {
    return distanceFromEnd(firstNode);
  }

  //option 3: recursion
  private int distanceFromEnd(Node<T> startingNode) {
    if (startingNode == null) {
      return 0;
    } else {
      return 1 + distanceFromEnd(startingNode.getNext());
    }
  }
}

class Node<T> {

  private Node<T> next = null;
  final private T value;

  public Node(final T value) {
    assert value != null;
    this.value = value;
  }

  public Node<T> getNext() {
    return next;
  }

  public void setNext(final Node<T> next) {
    this.next = next;
  }

  public T getValue() {
    return value;
  }

  @Override
  public String toString() {
    return value.toString();
  }
}

class对象链接列表{
公共静态void main（字符串…参数）{
final ObjectLinkedList=新建ObjectLinkedList（）；
列表。添加（0，“世界”）；
添加（0，“你好”）；
列表。添加（2，“！”）；
系统输出打印项次（列表）；
System.out.println（list.size（））；
}
私有节点firstNode=null；
公共无效添加（整数索引，T obj）{
最终节点newNode=新节点（obj）；
Node tempNode=firstNode；
如果（索引==0）{
firstNode=newNode；
setNext（tempNode）；
返回；
}否则{
整数计数=0；
//选项1：for循环
for（节点当前=第一个节点；当前！=null；当前=当前。getNext（））{
tempNode=current.getNext（）；
如果（++count==索引）{
current.setNext（newNode）；
setNext（tempNode）；
返回；
}
}
}
抛出新的IndexOutOfBoundsException（“出界！”）；
}
公共字符串toString（）{
节点tmp=第一个节点；
StringBuilder res=新的StringBuilder（“ObjectLinkedList:[”）；
//选项2：while循环
while（tmp！=null）{
附加资源（tmp）；
tmp=tmp.getNext（）；
如果（tmp！=null）{
决议附件（“，”）；
}
}
返回res.append（“]”）.toString（）；
}
公共整数大小（）{
返回distanceFromEnd（第一个节点）；
}
//选项3：递归
专用int距离fromEnd（节点开始节点）{
if（startingNode==null）{
返回0；
}否则{
返回1+distanceFromEnd（startingNode.getNext（））；
}
}
}
类节点{
私有节点next=null；
最终私有T值；
公共节点（最终T值）{
断言值！=null；
这个值=值；
}
公共节点getNext（）{
下一步返回；
}
公共void setNext（最终节点next）{
this.next=next；
}
公共T getValue（）{
返回值；
}
@凌驾
公共字符串toString（）{
返回值.toString（）；
}
}

您是否在调试器中仔细检查过它以查看大小的计算方式？看起来很好，可能是.add（）方法中的错误。请粘贴完整的代码可能您的

列表。add（）

工作不正常？--无论如何，为什么要在

size（）

方法中捕获

NullPointerException

？不要还有，为什么

nextNode！=null

是否签入

getNext（）

方法？不要，我更新了整个代码。我的find方法、remove、remove是否都因为size（）方法而出现问题？我想主要的问题可能是我的添加方法。如果列表为空怎么办？如果列表包含几千个条目怎么办？OP显示了一个封装的类ObjectLinkedList。它由低级节点类实现，但不公开。虽然递归或迭代可用于计算低级节点链中的项目，但其成本与节点数成线性关系。一个包含一组私有节点的封装类可以轻松地在固定时间内维护和报告大小。改变了我的方法。那么，如果我不想使用大小字段呢？还有其他方法解决这个问题吗？我遵循了您在add方法中所做的操作。但我现在有一个NPE是的，当然。我认为，这是因为

for

循环在索引处查找要插入新节点的节点，但它应该分别查找索引之前的节点。我会更新我的答案。

list = new ObjectLinkedList();
m1 = new Money(5, (byte) 6);
node1 = new Node(m1);
list.add(0, node1);
m2 = new Money(2, (byte) 4);
node2 = new Node(m2);
list.add(1, node2);
System.out.println(list.size());

list = new ObjectLinkeList();
m1 = new Money(5, (byte) 6);
list.add(m1);
m2 = new Money(2, (byte) 4);
list.add(m2);
System.out.println(list.size());

list = new ObjectLinkeList();
list.add(new Money(5, (byte) 6));
list.add(new Money(2, (byte) 4));
System.out.println(list.size());

class ObjectLinkedList<T> {

  public static void main(String... args) {
    final ObjectLinkedList<String> list = new ObjectLinkedList<>();
    list.add(0, "World");
    list.add(0, "Hello");
    list.add(2, "!");
    System.out.println(list);
    System.out.println(list.size());
  }

  private Node<T> firstNode = null;

  public void add(int index, T obj) {
    final Node<T> newNode = new Node<>(obj);
    Node<T> tempNode = firstNode;
    if (index == 0) {
      firstNode = newNode;
      firstNode.setNext(tempNode);
      return;
    } else {
      int count = 0;
      //option 1: a for loop
      for (Node<T> current = firstNode; current != null; current = current.getNext()) {
        tempNode = current.getNext();
        if (++count == index) {
          current.setNext(newNode);
          newNode.setNext(tempNode);
          return;
        }
      }
    }
    throw new IndexOutOfBoundsException("Out of bounds!");
  }

  public String toString() {
    Node<T> tmp = firstNode;
    StringBuilder res = new StringBuilder("ObjectLinkedList: [");
    //option 2: a while loop
    while (tmp != null) {
      res.append(tmp);
      tmp = tmp.getNext();
      if (tmp != null) {
        res.append(", ");
      }
    }
    return res.append("]").toString();
  }

  public int size() {
    return distanceFromEnd(firstNode);
  }

  //option 3: recursion
  private int distanceFromEnd(Node<T> startingNode) {
    if (startingNode == null) {
      return 0;
    } else {
      return 1 + distanceFromEnd(startingNode.getNext());
    }
  }
}

class Node<T> {

  private Node<T> next = null;
  final private T value;

  public Node(final T value) {
    assert value != null;
    this.value = value;
  }

  public Node<T> getNext() {
    return next;
  }

  public void setNext(final Node<T> next) {
    this.next = next;
  }

  public T getValue() {
    return value;
  }

  @Override
  public String toString() {
    return value.toString();
  }
}