如何使用迭代器迭代替代元素？

Question

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

上面的代码将依次迭代 1 到 6。我们可以交替迭代同一个列表，以便在不更改 while 循环的情况下打印1, 3, 5？

Answer 1

创建您自己的Iterator。

class SkippingIterator<T> implements Iterator<T> {
    private List<T> list;
    private currentPosition;
    private int skipBy;
    public SkippingIterator(List<T> l) {
        this(l, 2);
    }
    public SkippingIterator(List<T> l, int skip) {
        this(l, skipBy, 0);
    }
    public SkippingIterator(List<T> l, int skip, int startPosition) {
        list = l;
        skipBy = skip;
        currentPosition = startPosition;
    }
    public boolean hasNext() {
        return currentPosition < list.size();
    }
    public T next() {
        T result = list.get(currentPosition);
        currentPosition += skip;
        return result;
    }
}

编写代码

List<Integer> list = Arrays.asList(1,2,3,4,5,6);
Iterator it = new SkippingIterator<>(list);
while(it.hasNext()){
    System.out.println(it.next());
}

Answer 2

您只想打印奇数？使用流过滤列表：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Iterator<Integer> it = list.stream().filter(x -> x % 2 == 1).iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

编辑：

如果您想获取所有其他元素，那么使用流将不太合适，但您仍然可以这样做：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
int limit = list.size() / 2 - (1 - list.size() % 2);
Iterator<Integer> it = IntStream.iterate(0, x -> x + 2).limit(limit).map(list::get).iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

我推荐大牛的解决方案。

Answer 3

一个简单的机制是只使用列表项的索引：

IntStream.range(0, list.size())
    .filter(i -> i % 2 == 0)
    .mapToObj(list::get)
    .forEach(System.out::println);

如果您特别想要一个迭代器，只需调用 iterator() 而不是 forEach。

Answer 4

是的，你可以。在 while 循环体中，检查迭代器是否有下一个元素，如果有，则再次推进迭代器。这将导致不打印偶数元素。

List<Integer> list=Arrays.asList(1,2,3,4,5,6);
Iterator it=list.iterator();
while (it.hasNext()){
    System.out.println(it.next());
    if (it.hasNext()) {
        it.next();
    }
}

Answer 5

我认为 java-8 的做法是这样的：

class Skipping extends AbstractSpliterator<Integer> {

    private List<Integer> list;
    private int index = 0;

    public Skipping(List<Integer> list) {
        super(list.size() / 2, 0);
        this.list = new ArrayList<>(list);
    }

    @Override
    public boolean tryAdvance(Consumer<? super Integer> action) {
        if (index != list.size()) {
            if (index % 2 == 0) {
                action.accept(list.get(index++));
            }
            ++index;
            return true;
        }
        return false;
    }

}

及用法：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Iterator<Integer> iter = StreamSupport.stream(new Skipping(list), false).iterator();

Answer 6

您可以创建一个包装已经存在的迭代器的迭代器实现：

class IteratorWrapper<T> implements Iterator<T> {
    private final Iterator<? extends T> iterator;

    public IteratorWrapper(Iterator<? extends T> iterator){
        this.iterator = iterator;
    }

    public boolean hasNext(){
        return iterator.hasNext();
    }

    public T next(){
        final T next = iterator.next();
        if(iterator.hasNext()){
            iterator.next();
        }
        return next;
    }

    public void remove(){
        iterator.remove();
    }
} 

使您的代码如下：

List<Integer> list = Arrays.asList(1,2,3,4,5,6);
Iterator<Iterator> it = new IteratorWrapper<>(list.iterator());
while(it.hasNext()){
    System.out.println(it.next());
}

Answer 7

Iterator 实现，它包装了一个已经存在的迭代器。它为备用迭代器提供了hasNext() 方法的逻辑正确定义，因为hasNext() 方法只有在存在备用位置编号时才应返回true。

    import java.util.Iterator;

    public class AlternateIterator<T> implements Iterator<T>{

        private T next;
        private Iterator<T> it;

        public AlternateIterator(Iterator<T> it) {
            this.it = it;
            next = null;
        }
        // Logically hasNext() of this iterator should return true only if it has a valid alternate element present.
        @Override
        public boolean hasNext() {
            if(next != null) {
                return true;
            }
            if(it.hasNext()) {
                it.next();
                if(it.hasNext()) {
                    next = it.next();
                    return true;
                }
            }
            return false;
        }

        @Override
        public T next() {
            if(next != null) {
                T temp = next;
                next = null;
                return temp;
            }
            else {
                if(hasNext())
                    return next();
                else
                    return null;
            }
        }
    }

Answer 8

从任何底层迭代器创建您自己的自定义迭代器：

class TwoStepsAtOnceIterator<E> implements Iterator<E> {
    private Iterator<E> internal;
    public TwoStepsAtOnceIterator(Iterator<E> it) {
      internal = it;
    }
    public boolean hasNext() {
      return internal.hasNext();
    }
    public E next() {
      // problem not specified when underlying sequence has odd number of elements
      internal.next();
      return internal.next();
    }
    public void remove() {
      throw new UnsupportedOperationException();
    }
}

Answer 9

一个非常简单的代码是这样的：

List<Integer> list = Arrays.asList(1,2,3,4,5,6);
Iterator it = list.iterator();
while(it.hasNext()){
   static int i=0;
    if(i%2==0){
    System.out.println(it.next());
     }
     i+=1;
}