具有匿名内部类的双重通用链接列表（在函数中）

Question

我删除了我的上一篇文章，然后我再次重写了这个问题（在我学会了如何做之后，有什么要求。

1.我需要将Nodedouble定义为通用内部类 - 私有。 在这个类中，我需要编写使用数据和字符串方法的构造函数。

2.我需要在没有元素的需要构造函数的类中定义Linkedlistdouble。 Methode添加元素和方法来显示列表。

3.在LinkedListdouble类中，我需要定义从listiteartor类型返回对象的方法listiterator。 在functiob listiterator中我需要返回3方法： - T next - 返回下一个元素 - 如果列表iteartor有更多元素，则Boolean具有next-return true - T previous-如果没有元素则返回列表中的前一个元素 - 退货例外..

这是我的代码：

在这里输入代码

public class DoublyLinkedList<T> {
/**
 * 
 * @author USER
 *
 * @param <T>
 */
    class Node <T>{

        private T data;
        private Node previous;
        private Node next;

        Node(T data) { 
            this.data = data; 

        }
        public Node previous() { 
            return this.previous; 
        }

        public Node next() { 
            return this.next; 
        }

        public T getContent() { 
            return this.data; 
        }

        public void setPrevious(Node previous) { 
            this.previous = previous; 
        }
        public void setNext(Node next) { 
            this.next = next; 
        }

        public String toString() { 
            return data.toString(); 
            }
    }


    private Node head;
    private Node tail;
    private int size = 0;

    public Node head() { 
        return this.head;
        }

    public Node tail() {
        return this.tail; 
        }

    public void add(T element) {
        Node newNode = new Node(element);
        if (this.size == 0) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.setNext(newNode);
            newNode.setPrevious(this.tail);
            this.tail = newNode;
        }
        this.size++;
    }
    /*
     public boolean isEmpty(){

            return size==0;

        }
      public void push(int data){
            Node n= new Node(data);
            if(isEmpty()) {
                tail=n;
                head=n;
            }
            else {
               head.previous = n;
               n.next=head;
                head=n;
            }
            size++;
        }*/


    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node currentNode = this.head;
        while (currentNode != null) {
            stringBuilder.append(currentNode.getContent()).append(" ");
            currentNode = currentNode.next();
        }
        System.out.println(stringBuilder.toString().trim());
        return stringBuilder.toString().trim();
    }

    public ListIterator listIterator() {

        return new ListIterator() {
            Node curr;

            public boolean hasNext() {
                return curr.next() != null;
            }

            public T next() {
                T element = (T) curr.getContent();
                curr = curr.next();
                return element;
            }
            public T previous()  {
                T element = (T) curr.getContent();
                if(curr.previous()!=null) {
                curr = curr.previous();
                return element;
                }
                throw new NoSuchElementException();
            }
            @Override
            public boolean hasPrevious() {
                if(curr.previous() != null) {
                    return true;
                }
                return false;
            }
            @Override
            public void add(Object e) {
             throw new UnsupportedOperationException();             
            }
            @Override
            public int nextIndex() {
                throw new UnsupportedOperationException();              
            }
            @Override
            public int previousIndex() {
                throw new UnsupportedOperationException();              
            }
            @Override
            public void remove() {
                throw new UnsupportedOperationException();              

            }

            @Override
            public void set(Object e) {
                throw new UnsupportedOperationException();              

            }
        };

    }
     public static void main (String[]args) {
         DoublyLinkedList<Integer> a = new DoublyLinkedList();
            a.add(7);
            a.add(8);
            a.add(9);
            a.add(10);
            a.toString();

            ListIterator <Integer> iter = a.listIterator();
            while (iter.hasNext()) {
                System.out.println(iter.next());

            }

     }
        }

我的问题：1。当我尝试在主要代码中执行此代码时，我得到了一个错误：我如何解决它？ （主要在上面）

2. 我正在阅读一些关于匿名内部类的文章，我不知道我是否确实在这个练习中做得很好（在函数列表器中我尝试定义匿名内部类但我不知道这是否是这样做的方法..

谢谢！ 祝你有美好的一天

Answer 1

对listIterator进行一些更改：

Node curr = head //否则为null

将curr.next（）更改为hasNext（）方法中的cur，否则不会获取最后一个元素。

public boolean hasNext() {
     return curr != null;
}

希望有所帮助

RR

Answer 2

最直接的方法就是在listIterator中为head或tail添加一个参数：

ListIterator<Integer> iter = a.listIterator(a.getHead());

    while (iter.hasNext()) {
        System.out.println(iter.next());

    }

    iter = a.listIterator(a.getTail());

    while (iter.hasPrevious()) {
        System.out.println(iter.previous());

    }

我修改了你的ListIterator：

public ListIterator listIterator(Node start) {

    return new ListIterator() {
        DoublyLinkedList.Node curr = start;


        public boolean hasNext() {
            //System.out.println(curr);
            return curr != null;
        }

        public T next() {
            T element = (T) curr.getContent();
            curr = curr.next();
            return element;
        }

        public T previous() {
            T element = (T) curr.getContent();
            curr = curr.previous();
            return element;
        }

        @Override
        public boolean hasPrevious() {
            return curr != null;
        }

可能有更好的方法来做到这一点，比如创建自己的迭代器。 RR