0
我在學習Java第6版中的數據結構和算法時嘗試自己構建鏈接位置列表。 Position實現Node來存儲數據。 我想構建兩個迭代器，一個用於迭代位置，另一個用於迭代位置中的元素。所以我認爲2種for-each循環可以作爲以下應用：java迭代器無法應用於for_each
LinkedPositionalList<String> list = new LinkedPositionalList<>();
list.addFirst("A");
list.addLast("B");
list.addLast("V");
for (Position posi : list.positions()) {
}
for (String str:list) {
}
事實證明，第二次爲-各不適用輸入，但第一個運作良好。那麼如何讓每個迭代器的第二個工作？
這是我建立這樣的類的代碼： ps：代碼很長。嵌套類的最後一部分試圖實現Iterator接口。之前的代碼是構建鏈接位置列表的方式，我認爲並不重要...
public class LinkedPositionalList<E> implements PositionalList<E> {
private static class Node<E> implements Position<E> {
private E element;
private Node<E> prev;
private Node<E> next;
public Node(E e, Node<E> p, Node<E> n) {
element=e;
prev=p;
next=n;
}
public E getElement() throws IllegalStateException {
if (next == null) {
throw new IllegalStateException("Position no longer valid");
}
return element;
}
public Node<E> getPrev() {
return prev;
}
public Node<E> getNext() {
return next;
}
public void setElement(E e) {
element=e;
}
public void setPrev(Node<E> prev) {
this.prev = prev;
}
public void setNext(Node<E> next) {
this.next=next;
}
}
private Node<E> header;
private Node<E> trailer;
private int size=0;
public LinkedPositionalList() {
header = new Node<>(null, null, null);
trailer = new Node<>(null, header, null);
header.setNext(trailer);
}
private Node<E> validate(Position p)throws IllegalArgumentException {
if (!(p instanceof Node)) {
throw new IllegalArgumentException("Invalid p");
}
Node<E> node=(Node<E>)p;
if (node.getNext() == null) {
throw new IllegalArgumentException("p is no longer in the list");
}
return node;
}
private Position<E> position(Node<E> node) {
if (node == header || node == trailer) {
return null;
}
return node;
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public Position<E> first() {
return position(header.getNext());
}
public Position<E> last() {
return position(trailer.getPrev());
}
public Position<E> before(Position<E> p) throws IllegalArgumentException {
Node<E> node = validate(p);
return position(node.getPrev());
}
public Position<E> after(Position<E> p) throws IllegalArgumentException {
Node<E> node = validate(p);
return position(node.getNext());
}
public Position<E> addBetween(E e, Node<E> pred, Node<E> succ) {
Node<E> newest = new Node<>(e, pred, succ);
pred.setNext(newest);
succ.setPrev(newest);
size++;return newest;
}
public Position<E> addFirst(E e) {
return addBetween(e, header, header.getNext());
}
public Position<E> addLast(E e) {
return addBetween(e, trailer.getPrev(), trailer);
}
public Position<E> addBefore(Position<E> p, E e) throws IllegalArgumentException {
Node<E> node = validate(p);
return addBetween(e, node.getPrev(), node);
}
public Position<E> addAfter(Position<E> p,E e) throws IllegalArgumentException {
Node<E> node = validate(p);
return addBetween(e,node,node.getNext());
}
public E set(Position<E> p, E e) throws IllegalArgumentException {
Node<E> node = validate(p);
E answer = node.getElement();
node.setElement(e);
return answer;
}
public E remove(Position<E> p)throws IllegalArgumentException {
Node<E> node = validate(p);
Node<E> pre = node.getPrev();
Node<E> succ = node.getNext();
pre.setNext(succ);
succ.setPrev(pre);
size--;
E answer = node.getElement();
node.setNext(null);
node.setPrev(null);
node.setElement(null);
return answer;
}
//Here is the part that I think should be redesigned!!!!
private class PositionIterator implements Iterator<Position<E>> {
private Position<E> cursor = first(); // position of the next element to report
private Position<E> recent = null; // position of last reported element
public boolean hasNext() { return (cursor != null); }
public Position<E> next() throws NoSuchElementException {
if (cursor == null) throw new NoSuchElementException("nothing left");
recent = cursor; // element at this position might later be removed
cursor = after(cursor);
return recent;
}
public void remove() throws IllegalStateException {
if (recent == null) throw new IllegalStateException("nothing to remove");
LinkedPositionalList.this.remove(recent); // remove from outer list
recent = null; // do not allow remove again until next is called
}
} //------------ end of nested PositionIterator class ------------
//---------------- nested PositionIterable class ----------------
private class PositionIterable implements Iterable<Position<E>> {
public Iterator<Position<E>> iterator() { return new PositionIterator(); }
} //------------ end of nested PositionIterable class ------------
public Iterable<Position<E>> positions() {
return new PositionIterable(); // create a new instance of the inner class
}
//---------------- nested ElementIterator class ----------------
private class ElementIterator implements Iterator<E> {
Iterator<Position<E>> posIterator = new PositionIterator();
public boolean hasNext() { return posIterator.hasNext(); }
public E next() { return posIterator.next().getElement(); } // return element!
public void remove() { posIterator.remove(); }
}
public Iterator<E> iterator() { return new ElementIterator(); }
}
起初，我上傳了一個完全錯誤的版本...我需要修改並添加圖片來描述情況 –