Java 在LinkedList中使用递归时出现索引越界异常

因此，在大多数情况下，我需要使用递归方法计算LinkedList中的元素数。然而，我被抛出了一个越界异常。我似乎无法解决这个问题

import java.util.*;
import java.util.LinkedList;

public class ListCount {
public static LinkedList<String> ll = new LinkedList<String>();

public static void main(String[] args) {
    int size = 0;
LinkedList<String> list = new LinkedList<String>();
list.add("Hi");
list.add("I");
list.add("am");
list.add("a");
list.add("programmer");
list.add("and");
list.add("I");
list.add("am");
list.add("currently");
list.add("working");
list.add("on");
list.add("an");
list.add("assignment");
list.add("that");
list.add("is");
list.add("based");
list.add("on");
list.add("linkedlists");
list.add("for");
list.add("java");

ll = list;

countsize(size);


}
    public static int countsize(int somevalue)
    {
   Iterator next = ll.listIterator(somevalue);  
    {
        if (next == null)
    {
      return 0; 
    }
    else 
    {
    countsize(somevalue + 1);
    }
   System.out.println(somevalue);
    }
  return 0;
}    

---

next

将永远不会为空，因为

listIterator

将始终返回一个

Iterator

。您需要检查的是，

迭代器本身是否有下一个元素。因此，改变：

if(next == null)

到

这里就是问题所在，您需要使用interator
next
（将其重命名为listItr或其他名称以避免混淆）来获取下一个元素（如果有）。请看下面的示例：

  // Set Iterator at specified index
  Iterator x = list.listIterator(1);

  // Get the next element with the iterator
  if (x.hasNext()) {
     System.out.println(x.next());
  }

使用此代码也可以避免
NoTouchElementException
。
您需要交互。
将if（next==null）替换为if（next.next（）==null）
您在以下几点上犯了错误：


您对列表的构造太冗长了
您的测试
next==null
应该是
next.hasNext（）
，但我将其重命名为
it
无论发生什么，您总是返回0，并且从不使用递归调用的结果

以下是一个可行的解决方案：

public class ListCount {
    public static LinkedList<String>    ll  = new LinkedList<String>();

    public static void main(String[] args) {
        String s = "Hi I am a programmer and I am currently working on an assignment that is based on " +
                "linkedlists for java";
        ll = new LinkedList<String>(Arrays.asList(s.split("\\s+")));
        System.out.println(countsize(0));
        System.out.println(ll.size());
    }

    public static int countsize(int somevalue) {
        Iterator<String> it = ll.listIterator(somevalue);
        return it.hasNext() ? countsize(somevalue + 1) + 1 : 0;
    }
}

公共类列表计数{
public static LinkedList ll=new LinkedList（）；
公共静态void main（字符串[]args）{
String s=“嗨，我是一名程序员，目前正在处理一项基于+
“用于java的LinkedList”；
ll=新的LinkedList（Arrays.asList（s.split（\\s+）））；
System.out.println（countsize（0））；
System.out.println（ll.size（））；
}
公共静态int countsize（int somevalue）{
迭代器it=ll.listIterator（somevalue）；
返回它。hasNext（）？countsize（somevalue+1）+1:0；
}
}
有两个问题：

终止时需要检查
next.hasNext（）
您需要修复递归：当前，methid将始终返回
0
，因为您忽略了递归返回值
试试这个：

public static int countsize(int somevalue) {
    Iterator next = ll.listIterator(somevalue);  
    if (!next.hasNext())
        return someValue; 
    System.out.println(somevalue);
    return countsize(somevalue + 1);
}

基本问题是#countsize（int）方法无限递归，直到它尝试实例化一个迭代器，其起始索引超出列表范围。“（next==null）”谓词永远不会传递，因为List.listIterator（int）永远不会返回null

这就像用相同的索引调用LinkedList.get（int）-您可以在该索引处获取值（或者对于#listIterator（int）方法，迭代器从该索引处开始），或者如果您给出的索引大于列表中的最高索引，则抛出IndexOutOfBoundsException

对赋值的限制做一些假设，我猜您需要使用迭代器（而不仅仅是使用#get（int））。如果是这种情况，您可能应该在main方法中使用#Iterator（void）实例化一个迭代器，并将其传递给count方法。该方法应该在调用#next（）和递归之前递归地检查#hasNext（）方法

否则，您可以在catch块中处理IndexOutOfBoundsException？
如果迭代器没有下一个元素（并将抛出NosTouchElementException），则这将不起作用。这也。。。如果不将迭代器移动到下一个元素，它将永远循环。啊，这是一个简单的错误！现在很好用，谢谢@多明你不需要移动它，你只需要检查它是否有下一个元素…@user2336315这句话不足以让代码正常工作。看我的answer@Dici你可以用我的解决方案试试他的代码。他不需要返回值，他正在打印它。我没有说这是解决方案，只是给出了指针，为什么他得到了一个无限递归。。。不需要向下投票。无论是谁“要求”你通过递归计算列表中的元素数量，都是在要求一些非常荒谬的事情。如果列表中有足够的元素，无论代码写得多好，都会出现堆栈溢出错误。更好的方法是使用while循环对元素进行计数，或者简单地调用列表本身的size（）函数。
public class ListCount {
    public static LinkedList<String>    ll  = new LinkedList<String>();

    public static void main(String[] args) {
        String s = "Hi I am a programmer and I am currently working on an assignment that is based on " +
                "linkedlists for java";
        ll = new LinkedList<String>(Arrays.asList(s.split("\\s+")));
        System.out.println(countsize(0));
        System.out.println(ll.size());
    }

    public static int countsize(int somevalue) {
        Iterator<String> it = ll.listIterator(somevalue);
        return it.hasNext() ? countsize(somevalue + 1) + 1 : 0;
    }
}

public static int countsize(int somevalue) {
    Iterator next = ll.listIterator(somevalue);  
    if (!next.hasNext())
        return someValue; 
    System.out.println(somevalue);
    return countsize(somevalue + 1);
}