Question

..并且反复，我的意思是重复。我有一个列表界面的简单实现，其功能类似于LinkedList的简单婴儿版本。

我有“Knoten”（德语中的“knot”），MyLinkedList以及Main。

我的编译器向我抛出的错误源于第35行的Knoten类。但它并没有告诉我它是什么样的错误。

“在Knoten.nextN（Knoten.java:35）”

它只是说。一百万次。我的整个cmd窗口都填满了这一行。我打赌它会一次又一次地打印这个错误信息超过一百次。我试图搜索类似的问题，但无法找到任何有用的东西，因为我不知道要搜索哪个错误。

为什么程序崩溃了？

请帮助..

Knoten：

class Knoten<T> {
Knoten nachfolger; 
T t; 

public Knoten(T t){
    this.t = t;
    nachfolger = null; 
}

public void add(T tneu) {
    if (nachfolger != null) {
        nachfolger.add(tneu);
    }
    else {
        Knoten kneu = new Knoten(tneu);
        nachfolger = kneu;
    }
}

public Knoten giveNachfolger(){
    return nachfolger;
}

public T fuerIDGeben(int index, Knoten anfang) {
    if(index == nextN(anfang)){
        return (T) nachfolger.t;
    }
    return null;
}

private int nextN(Knoten k){
    int i = 1;
    if (nachfolger != null){
        i = i+1; 
        nextN(nachfolger);
    } else {}
    return i;
} }

MyLinkedList：

class MyLinkedList<T> implements MyList<T>{

Knoten anfang; 

public MyLinkedList<T>(){
    anfang = null;
}


public T get(int index){
    return (T) anfang.fuerIDGeben(index, anfang);
}

public void add(T t){
    if(anfang != null){
        anfang.add(t);
    } else {
        Knoten newKnoten = new Knoten(t);
        anfang = newKnoten; 
    }
}

public MyIterator<T> iterate(){
    return new MyLinkedIterator<T>(); 
}

private class MyLinkedIterator<T> implements MyIterator<T>{

public boolean hasNext(){
    if(anfang.giveNachfolger() != null){
        return true;
        }
    return false;
}

public T next(){
    if(anfang.giveNachfolger() != null){
        return (T) anfang.giveNachfolger().t;
    }
    return null;
}}}

    import java.util.*;

主要：

class Main{

public static void main(String[] args){

MyList<Integer> list = new MyLinkedList<Integer>();

    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);

    System.out.println(list.get(0));

    MyIterator<Integer> it = list.iterate();
    while(it.hasNext()){
        System.out.println(it.next());
    }


}}

Answer 1

nextN()中有无限递归，导致堆栈溢出。

如果仔细观察nextN()的实现，它会反复使用相同的参数调用自己。这一直持续到JVM用完堆栈为止，此时你得到一个StackOverflowError。异常点处的堆栈跟踪将多次提及nextN()。

Answer 2

由于您未在k函数中使用nextN，因此它始终使用相同的参数调用自身并带来无限循环。

而不是那样，你应该使用k的成员变量调用nextN函数，以便迭代它们。

如果您有以下链接：

k - ＆gt; k.nachfolger - ＆gt; k.nachfolger.nachfolger - ＆gt; ...

然后你需要改变你的功能：

private int nextN(Knoten k){
    if (k.nachfolger != null){
        return nextN(k.nachfolger) + 1;
    } 
    return 1;
}

LinkedList中的重复错误

2 个答案: