Question

我有一个返回可迭代对象的接口。我需要迭代它的前1000个项目。使用Iterator进行迭代并在达到某个计数后停止的最佳方法是什么。

由于

Answer 1

我使用循环迭代并使计数器变量递增;然后当计数器达到1000时突然退出循环。

Answer 2

你的语言是什么？

C＃：

using System.Linq;
//...
foreach (var item in iface.GetIterable().Take(1000))
{
    //...
}

的Python：

import itertools
#...
for item in itertools.islice(iface.get_iterable(), 1000):
    #...

Answer 3

创建一个循环遍历集合的标准循环，但检查索引是否有超过目标索引的进度。

您可能希望从特定应用程序的主循环索引中提取单独的计数器。

int stopIndex = 1000;

for (int index = 0; index <= theInterface.Count; index++)
{
    // check to see if we're at/past the stopIndex
    if (index >= stopIndex)
        break;

    // we're still within the conditions, so do something with your interface
    myObjectType localObject = (MyObjectType)theInterface.IndexOf(index);
}

Answer 4

这是一个围绕任何现有迭代器的测试驱动（Java）包装器，应该可以解决这个问题。

package com.playground;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

public class LimitedIterableTest extends TestCase {

    private static class LimitedIterator<T> implements Iterator<T> {
        private final Iterator<T> original;
        private final int limit;
        private int index = 0;

        public LimitedIterator(Iterator<T> iterator, int limit) {
            this.original = iterator;
            this.limit = limit;
        }

        public boolean hasNext() {
            return index < limit && original.hasNext();
        }

        public T next() {
            index++;
            return original.next();
        }

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

    private static class LimitedIterable<T> implements Iterable<T> {
        private final int limit;
        private final Iterable<T> original;

        public LimitedIterable(Iterable<T> iterable, int limit) {
            this.original = iterable;
            this.limit = limit;
        }

        public Iterator<T> iterator() {
            return new LimitedIterator<T>(original.iterator(), limit);
        }
    }

    final Integer[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    final List<Integer> list = Arrays.asList(array);

    public void testCount() throws Exception {
        assertEquals(10, count(list));
    }

    public void testLimitedIterable() throws Exception {
        Iterable<Integer> limited = new LimitedIterable<Integer>(list, 5);
        assertEquals(5, count(limited));
        limited = new LimitedIterable<Integer>(list, 50);
        assertEquals(10, count(limited));
    }

    private static <T> int count(Iterable<T> iterable) {
        Iterator<T> iterator = iterable.iterator();
        return count(iterator);
    }

    private static <T> int count(Iterator<T> iterator) {
        int count = 0;
        while (iterator.hasNext()) {
            iterator.next();
            count++;
        }
        return count;
    }
}

迭代一系列可迭代的

4 个答案: