Itérer sur une plage d'itératives

Question

J'ai une interface qui renvoie un objet itérable. J'ai besoin d'itérer sur les 1000 premiers éléments de celui-ci. Quelle est la meilleure façon de combiner l'itération à l'aide de l'itérateur et de s'arrêter après avoir atteint un certain nombre.

Merci

Answer 1

j'utiliser une boucle qui itère et une variable de compteur incrémentée; Ensuite, quittez la boucle lorsque le compteur atteint 1000.

Answer 2

Créez une boucle standard qui itère sur votre collection, mais vérifiez si l'index a dépassé l'index cible.

Vous pouvez extraire un compteur séparé de l'index de boucle principal pour votre application spécifique.

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

Quelle est votre langue?

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

Voici un emballage piloté par les tests (Java) autour de tout iterator existant qui devrait faire l'affaire.

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