带有匿名内部类的java双泛型链表（函数中）

Question

我删除了我的上一篇帖子，并再次重写了这个问题（在我学会如何做以及要求是什么之后）

一,。我需要将Nodedouble定义为一个通用的内部类——private。在这个类中，我需要编写使用数据和字符串方法的构造函数

二,。我需要在这个没有元素的类中定义Linkedlistdouble。Methode添加元素并显示列表

三,。在LinkedListdouble类中，我需要定义从类型listiterator返回对象的方法listiterator。在functiob listiterator中，我需要返回3个方法： -T next-返回下一个元素 -如果列表iteartor包含更多元素，则布尔值next返回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. 当我尝试在主界面执行以下代码时，我犯了一个错误： 我怎么能修好它？（主要内容见上图）

1. 我正在阅读一些关于匿名内部类的文章，我不知道我在这个练习中是否做得对（在函数listiterator中，我试图定义匿名内部类，但我不知道这是否是实现它的方法。）

谢谢!！ 祝你今天愉快

Answer 1

最直接的方法就是在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

Answer 2

对listIterator的几个更改：

节点curr=head//否则为空

换现金。在hasNext（）方法中，next（）到cur，否则不会得到最后一个元素

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

希望有帮助

RR