标签: listiterator

Iterator ite = Set.iterator();
Iterator ite = List.iterator();

ListIterator listite = List.listIterator();

我们可以Iterator用来遍历一个Set或一个List或一个Map.但是ListIterator只能用来遍历一个List,它不能遍历一个Set.为什么？

我知道主要区别在于,使用迭代器,我们只能朝一个方向行进,但ListIterator我们可以向两个方向行进.还有其他差异吗？ListIterator超过任何优势Iterator？

可能重复:
Java:在迭代期间向集合添加元素

我的问题是我想在迭代它时使用新元素扩展一个列表,我希望迭代器继续我刚刚添加的元素.

根据我的理解ListIterator.add(),在列表中的当前元素之前添加元素,而不是在它之后.是否有可能以其他方式实现这一目标？

我知道我们可以使用advance()函数来增加迭代器.我们还使用iterator++一个位置来增加迭代器.为什么我们不能使用it+=2？

int main()
{
    list<int> l1{1, 2, 3, 5, 6};
    list<int> l2{2, 6, 8};
    auto it = l1.begin();
    advance(it, 2);         //works
    it++;                   //works
    // it+=2;                  //not work
    l2.splice(l2.begin(), l1, it);

    for(int a: l2) cout<<a<<" ";
    cout<<endl;

    return 0;
}

您可以在此处运行上述代码.

我正在使用selenium,我正在使用函数FindElements,所以我得到一个实现IReadOnlyCollection接口的元素.我想迭代列表,但似乎IReadOnlyCollection没有任何方法,如Get(int index)或操作[]的实现.

我想避免将结果转换为List或数组,因为我只想访问元素来读取它们.

目前我不想使用foreach,因为我需要管理索引,所以我可以将这些元素添加到另一个数组.

这就是我想要做的:

public void fillMatrix(){
    IReadOnlyCollection<IWebElement> rows = Driver.FindElements(By.XPath("./*/tr"));            
        IReadOnlyCollection<IWebElement> elements;
        matrix = new IControl[rows.Count()][];
        for(int i = 0; i < matrix.Count(); ++i){
            matrix[i] = rows[i].FinElements("./td").toArray();                
        }    
}

谢谢

让我们来看看这个例子:

public class ListIteratorTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("element1");
        list.add("element2");
        list.add("element3");
        list.add("element4");

        ListIterator<String> iterator = list.listIterator();
    }
}

现在,这很好用:

    // prints elements out, and then appropriately removes one after another
    while (iterator.hasNext()){
        System.out.println(iterator.next());
        iterator.remove();
    }

虽然这会抛出IllegalStateException:

        // throws IllegalStateException, why?
        iterator.forEachRemaining(n -> {
            System.out.println(n);
            iterator.remove();
        });

我的问题很简短:为什么？

我是新来的语言.我希望在根据go语言中的条件迭代列表时从列表中删除元素.例如,我想从列表中删除重复的元素.代码如下.

package main
import (
    "container/list"
    "fmt"
)
var sMap map[int]bool
func main() {
    l := list.New()
    l.PushFront(4)
    l.PushFront(5)
    l.PushFront(7)
    l.PushFront(6)
    l.PushFront(5)
    l.PushFront(4)
    l.PushFront(5)
    l.PushFront(7)
    l.PushBack(9)
    l = removeDuplicate(l)
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Println(e.Value)
    }
}
func removeDuplicate(l *list.List) *list.List {
    sMap = make(map[int]bool)
    for e := l.Front(); e != nil; e = e.Next() {
        m := e.Value.(int)
        fmt.Println("VALUE : ", m)
        if sMap[m] == true {
            fmt.Println("Deleting ", e.Value)
            l.Remove(e)
        } else …

如果我有一个std::vector<int>,我可以通过减去两个迭代器来获得最小元素的索引:

int min_index = std::min_element(vec.begin(), vec.end()) - vec.begin();

但是,对于没有随机访问迭代器的容器,例如a std::list<int>,这不起作用.当然,有可能做类似的事情

int min_index = std::difference(l.begin(), std::min_element(l.begin(), l.end()));

但是我必须在列表中迭代两次.

我可以通过在列表中迭代一次来获取具有STL算法的最小值的元素的索引,还是必须编写自己的for循环代码？

package wrap;
import java.util.*;
public class ArrayListDemo {

    public static void main(String [] args){
        ArrayList<String> a=new ArrayList<String>();
        a.add("B");
        a.add("C");
        a.add("D");
        ListIterator<String> i=a.listIterator();
        while(i.hasPrevious()){
            System.out.println(i.previous());
        }
    }

}

该程序适用于hasNext()和next()方法,但对于hasPrevious()和previous(),它显示如下消息::

<terminated> ArrayListDemo [Java Application] C:\Program Files (x86)\Java\jre7\bin\javaw.exe (28-Oct-2013 3:20:35 PM)

我是Java Collections的新手,我怀疑为什么我不能在向后的方向上遍历链表中的元素.我将解释我做了什么,请澄清我的怀疑.

1. 我为前向迭代创建了接口迭代器,为后向迭代创建了listiterator.为什么反向迭代不起作用？

2. 我不能在同一个程序中使用iterator和listiterator接口来遍历前向和后向迭代中的一组元素吗？

   代码片段:

   import java.util.*;
   class NewClass{
   public static void main(String args[]){
     LinkedList<String> obj = new LinkedList<String>();
   
      obj.add("vino");
      obj.add("ajith");
      obj.add("praveen");
      obj.add("naveen");
   
      System.out.println(obj);
   
      System.out.println("For loop ");
      //using for loop
      for(int count=0; count < obj.size(); count++){
        System.out.println(obj.get(count));
      }
     System.out.println("For each loop ");
   
     //using foreach loop
     for(String s:obj){
        System.out.println(s);
     }
     System.out.println("Whileloop ");
   
     //using whileloop
     int count=0;
     while(obj.size() > count){
         System.out.println(obj.get(count));
       count++;
     }
     System.out.println("Forward Iterations ");
     //using iterator 
     Iterator it = obj.iterator();
     while(it.hasNext()){
        System.out.println(it.next()); …

   Run Code Online (Sandbox Code Playgroud)

假设我有一个非常大的整数列表,占用了大量的内存.如果列表的整数是偶数增量,那么我可以很容易地将列表表示为占用相对没有内存的迭代器.但是对于更复杂的模式,将此列表表示为迭代器将变得更加困难.

是否有一个Python包可以分析整数列表并返回"优化"迭代器？或者我可以研究的方法来实现这个目标？