Java: iterando a través de la lista de listas?

Question

The question but in C#. Entonces, ¿Java tiene el comando C#? Lo necesito para Matches-SearchTerm-Files-relationship.

foreach(var i in BunchOfItems.SelectMany(k => k.Items)) {} 

[¿Por qué no para-bucles?] he hecho este tipo de estructuras en bucles for anidados pero pronto se convertirá hinchado. Así que prefiero algo más succint como el de arriba.

public static Stack<Integer[]> getPrintPoss(String s,File f,Integer maxViewPerF) 
{ 
    Stack<File> possPrint = new Stack<File>(); 
    Integer[] poss = new Integer[4](); 
    int u,size; 
    for(File f:files) 
    { 
     size = f2S(f).length(); 
     u = Math.min(maxViewsPerF,size); 
     for(int i=0; i<u;i++) 
     { 
      // Do something --- bloated, and soon out of control 
      // wants more succintly 

     } 
    } 
    return possPrint; 
} 

Answer 1

tienen cerca de la mitad de un año, hasta que la paciencia es JDK7 final que incluirá Closures. Esto proporciona una sintaxis similar y las mismas posibilidades que LINQ que se demostró en la respuesta de la que está hablando.

Answer 2

for (List<Object> lo : list) { 
    for (Object o : lo) { 
     // etc etc 
    } 
} 

No creo que haya una solución más simple.

Answer 3

Tengo mi propia versión. Esperando desesperadamente cierres en Java:

public static <T, E> Iterable<T> transformMany(Iterable<E> iterable, Func<E, Iterable<T>> f) { 
    if (null == iterable) 
     throw new IllegalArgumentException("null iterable"); 
    if (null == f) 
     throw new IllegalArgumentException("null f"); 

    return new TransformManyIterable<E, T>(iterable, f); 
} 

public interface Func<E, T> { 
    T execute(E e); 
} 

public class TransformManyIterable<TOriginal, TResult> implements Iterable<TResult> { 
    private Iterable<TOriginal> iterable; 
    private Func<TOriginal, Iterable<TResult>> func; 

    public TransformManyIterable(Iterable<TOriginal> iterable, 
      Func<TOriginal, Iterable<TResult>> func) { 
     super(); 
     this.iterable = iterable; 
     this.func = func; 
    } 

    class TransformIterator implements Iterator<TResult> { 
     private Iterator<TOriginal> iterator; 
     private Iterator<TResult> currentIterator; 

     public TransformIterator() { 
      iterator = iterable.iterator(); 
     } 

     @Override 
     public boolean hasNext() { 
      if (currentIterator != null && currentIterator.hasNext()) 
       return true; 
      else { 
       while (iterator.hasNext()) { 
        Iterable<TResult> iterable = func.execute(iterator.next()); 
        if (iterable == null) 
         continue; 
        currentIterator = iterable.iterator(); 
        if (currentIterator.hasNext()) 
         return true; 
       } 
      } 

      return false; 
     } 

     @Override 
     public TResult next() { 
      if (currentIterator != null && currentIterator.hasNext()) 
       return currentIterator.next(); 
      else { 
       while (iterator.hasNext()) { 
        Iterable<TResult> iterable = func.execute(iterator.next()); 
        if (iterable == null) 
         continue; 
        currentIterator = iterable.iterator(); 
        if (currentIterator.hasNext()) 
         return currentIterator.next(); 
       } 
      } 
      throw new NoSuchElementException(); 
     } 

     @Override 
     public void remove() { 
      throw new UnsupportedOperationException(); 
     } 
    } 

    @Override 
    public Iterator<TResult> iterator() { 
     return new TransformIterator(); 
    } 

} 

de uso:

Iterable<SomeType> result = transformMany(input, new Func<InputType, Iterable<SomeType>>() { 
     @Override 
     public Iterable<SomeType> execute(InputType e) { 
      return new ArrayList<SomeType>(); 
     } 
    }); 

Answer 4

El método SelectMany es parte de LINQ que es Net-específica. This question pregunta acerca de un LINQ equilvalent para java. Desafortunadamente, no parece que haya un equivalente directo.

Answer 5

Si puede obtener los datos en un Iterable<Iterable<T>>, puede obtenerlos de un Iterable<T> aplanado utilizando el método de Guava Iterables.concat. Si lo que tiene es realmente un Iterable<S>, con alguna forma de obtener desde un S hasta un Iterable<T>, entonces, primero tiene que usar Iterables.transform para verlo como el Iterable<Iterable<T>> necesario por concat.

Todo esto se verá mucho mejor si Java tiene algo parecido a cierres, pero al menos hoy es posible.

http://guava-libraries.googlecode.com

Answer 6

Con Java 8, se puede decir

Collection bunchOfItems = ...; 
bunchOfItems.stream().flatMap(k::getItems).forEach(i -> /* operate on i */); 

o

Item[] bunchOfItems = ...; 
Stream.of(bunchOfItems).flatMap(k::getItems).forEach(i -> /* operate on i */); 

dependiendo de si usted tiene un Collection o un Array.