反復可能な範囲で反復する

Question

反復可能なオブジェクトを返すインターフェイスを持っています。 私はそれの最初の1000項目を反復する必要があります。 Iteratorを使用して反復処理を組み合わせ、特定の回数に達した後に停止する最良の方法は何ですか。

おかげ

Answer 1

私はそれを反復処理ループを使用し、インクリメントカウンタ変数を持っていると思います。カウンターが1000に達するとループが途切れます。

Answer 2

コレクションを繰り返し処理する標準ループを作成しますが、インデックスがターゲットインデックスを超えて進行しているかどうかを確認してください。

特定のアプリケーションのメインループインデックスから別のカウンタを抽出することができます。

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 3

あなたの言語は？

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 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; 
    } 
}