Javaのリンクリストで2つの異なるイテレータを使用するにはどうすればよいですか？

Question

ヒューリスティックのすべての組み合わせを試して、要素の抽出と挿入を実行するためにリンクリストを使用したいと思います。リンクされたリストは、このタイプの操作の方が効率的です。 可能なすべての抽出/挿入のペアを試したいので、私はリストの上に2つの異なるイテレータを使用しました。これにより、 "ConcurrentModificationException"が発生します。どのようにして、リストを最初から再利用しようとしているのか、その都度、リストを再トラバースすることなく、効率的にこの操作を実行することができますか？

ListIterator<Integer> it1 = data.listIterator(); 
ListIterator<Integer> it2; 

while(it1.hasNext()) { 
    int i = it1.next(); 
    it2 = data.listIterator(); 

    while(it2.hasNext()) { 
     if (i == it2.next()) continue; // continue right away when the indexes are equal 
     it1.remove(); 
     it2.add(i); 
     if (length() < best) 
      return true; 
     } 

    // when the swap is not better/consistent 
    it2.remove(); 
    it1.add(i); 
} 
return false; 

おかげ

Answer 1

だけ読み出し動作を行っているときは、リスト上のイテレータの任意の数を使用することができます。

は、ここでは、コードの関連する部分です。ここでは削除/追加を行っているので、現在の状況でConcurrentModificationExceptionが発生するので、2つの異なるイテレータで同じリストを使用することはできません。

達成したいのは？多分、人々はさまざまな選択肢であなたを助けることができます。

あなたはしかし、あなたが CopyOnWriteArrayList

でこれ試してみてくださいすることができ、LinkedListの上で同時に複数のイテレータを使用することはできません

Answer 2

：私はあなたが権利を取得した場合、あなたはその申し出データ構造を探し

List<Integer> safeData = new CopyOnWriteArrayList(date); 
// your code, but working with safeData rather than data 

Answer 3

をリストを操作するためのいくつかのイテレータ。これは、現在のインデックスのハウスキーピングを行うため、元のjava.util.LinkedListでは技術的に困難です。これは、他のイテレータによってリスト内の未知の位置に並列変更がない場合にのみ効率的に可能です。しかし、このハウスキーピングをしない単純なLinkedListを簡単に実装することができ、いくつかのイテレータを使って追加/削除をサポートします。イテレータはリスト内の位置を知らないが、あなたは気にしないだろう。

public class MyList<T> { 
private MyNode<T> first = null, last = null; 

public MyNode<T> getFirst() { 
    return first; 
} 

public MyNode<T> getLast() { 
    return last; 
} 

public boolean contains(MyNode<T> n) { 
    return n.list == this; 
} 

/** 
* If beforeMe is null, toInsert is inserted at the end of the list. 
* @return inserted node 
*/ 
public void insertBefore(MyNode<T> beforeMe, MyNode<T> newNode) { 
    if (newNode == null) { 
     throw new IllegalArgumentException("toInsert must not be null!"); 
    } 

    if (newNode.list != null) { 
     throw new IllegalArgumentException("This node is already in the list " + newNode.list); 
    } 

    if (beforeMe == null) { 
     if (last == null) { 
      newNode.prev = newNode.next = null; 
      first = last = newNode; 
     } else { 
      last.next = newNode; 
      newNode.prev = last; 
      newNode.next = null; 
      last = newNode; 
     } 
    } else { 
     newNode.prev = beforeMe.prev; 
     newNode.next = beforeMe; 

     if (beforeMe.prev != null) { 
      beforeMe.prev.next = newNode; 
     } else { 
      first = newNode; 
     } 

     beforeMe.prev = newNode; 
    } 

    newNode.list = this; 
} 

/** 
* If beforeMe is null, t is inserted at the end of the list. 
* @return inserted node 
*/ 
public MyNode<T> insertBefore(MyNode<T> beforeMe, T t) { 
    MyNode<T> newNode = new MyNode<T>(t); 
    insertBefore(beforeMe, newNode); 
    return newNode; 
} 

public void remove(MyNode<T> n) { 
    if (n == null || n.list != this) { 
     throw new IllegalArgumentException("Node is not in the list!"); 
    } 

    if (n.prev != null) { 
     n.prev.next = n.next; 
    } else { 
     first = n.next; 
    } 

    if (n.next != null) { 
     n.next.prev = n.prev; 
    } else { 
     last = n.prev; 
    } 

    n.prev = n.next = null; 
    n.list = null; 
}} 

public class MyNode<T> { 

private T t; 
/** 
* written only by MyList 
*/ 
MyNode<T> prev = null; 
/** 
* written only by MyList 
*/ 
MyNode<T> next = null; 
/** 
* written only by MyList 
*/ 
MyList<T> list = null; 

public T get() { 
    return t; 
} 

public void set(T t) { 
    this.t = t; 
} 

public MyNode<T> previous() { 
    return prev; 
} 

public MyNode<T> next() { 
    return next; 
} 

public MyList<T> list() { 
    return list; 
} 

/** 
* called only by MyList. 
* @param t 
*/ 
MyNode(T t) { 
    this.t = t; 
}}