Question

我试图在不使用Iterable或Iterator接口的情况下实现双向链接列表。所以目前我有一个实现，但是我真的不明白如何将Iterator的实现连接到List。当我不使用解析每个构造函数的参数互相引用时，该如何工作。对我来说，这是一个非常深刻的问题，因为它暗示了Java的一些更大概念。感谢您的帮助。

我当前的解决方案是：

package info2.list;

import java.util.NoSuchElementException;

import info2.MyCollection;
import info2.list.Doublylinkedlist.ListElem;

public class Doublylinkedlist_Iterator<E> {

    protected ListElem currentItem;
    private int currentIndex = 0;

    public Doublylinkedlist_Iterator(ListElem currentItem) {
        this.currentItem = currentItem;
    }

    public boolean hasNext() {
        if (!(this.currentItem.next == null))
            return true;
        else
            return false;
    }

    public boolean hasPrevious() {
        if (!(this.currentItem.previous == null))
            return true;
        else
            return false;
    }

    public E next() throws NoSuchElementException { // Warum wurde dieser Datentyp als Parameter definiert?
        if (!this.hasNext())
            throw new NoSuchElementException("Es gibt kein nächstes Element.");
        E tmp = (E) currentItem; // MUss das hier den Inhalt/Value vom CurrentItem returnen? Is that properly
                                    // solved? Warum funktioniert es nicht mit ListElem? Welche Typenkonvertierugn
                                    // ist hier adaquat?
        currentItem = this.currentItem.next;
        currentIndex++;
        return tmp;
    }

    public E previous() throws NoSuchElementException {
        if (!this.hasPrevious())
            throw new NoSuchElementException();
        E tmp = (E) currentItem;
        currentItem = this.currentItem.previous;
        currentIndex--;
        return tmp;
    }
}

这是我的双向链接列表实现，到目前为止尚未完成。解决问题后，我将添加完整的版本。

package info2.list;

import java.util.ArrayList;

import info2.MyCollection;
import info2.list.Doublylinkedlist_Iterator;

public class Doublylinkedlist<E> {

    /*
     * Anonyme Innere Klasse
     */
    protected class ListElem {
        ListElem next;
        ListElem previous;
        E content;

        ListElem(E content, ListElem next, ListElem previous) {
            this.content = content;
            this.next = next;
            this.previous = previous;
        }

        protected ListElem getNext() {
            return this.next;
        }

        protected ListElem getPrevious() {
            return this.previous;
        }

        protected E getContent() {
            return this.content;
        }
    }

    // Normaleweise muesste die Anzahl der ITertoren einer Liste auch auf diese 2
    // beschränkt werden, sodasss man immer ausschließlich zwei Iteratoren hat
    protected Doublylinkedlist_Iterator<E> head;
    protected Doublylinkedlist_Iterator<E> tail;
    private int length;

    public Doublylinkedlist() {
        this.head = null;
        this.tail = null;
        this.length = 0;
    }

    public Doublylinkedlist_Iterator getIterator() {
        return new Doublylinkedlist_Iterator(this);
    }

如何连接双向链表和迭代器？

0 个答案: