añadiendo un argumento del método de mapa para el método foreach utilizando Java Corriente

Zak Zak:

Escribí un pequeño ejemplo para explicar mi problema:

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


public class Example {

     public static void main( String[] args )  {
         String [] array =  {"1 0101 5","1 0101 5"};
         Arrays.stream(array)
               .map(str->str.split(" "))//every String is mapped to an array of String
               .map(arr-> returnAListOf5Element( Integer.parseInt(arr[0]),arr[1],Integer.parseInt(arr[2])))
               .forEach(list-> tesMyList(list));//i want to send the Integer.parseInt(arr[2]) as a second argument
     }
    /**
     *
     * test if the list has size of 5
     */
    private static void testMyList(List<Integer> myList) {
         if (myList.size()==5)
             System.out.println("Ok");
    }

    /**
     *
     * return a list of 5 element
     * @return
     */
    private static List<Integer> returnAListOf5Element( int i, String s, int i1 ) {
         List list = Arrays.asList(1,2,3,4,5);
         return list;
    }
}

Así que tengo algunas cadenas como "1 5 0101", "0101 1 5" ....., yo uso el funcionamiento corriente para hacer algo de calcul.

El problema es que quiero añadir el argumento arr [2] encontró en el método del mapa para testMyList método que se encuentra en el método foreach.

el método testMyList debe ser como:

 private static void testMyList(List<Integer> myList, int size) {
         if (myList.size()==size)
             System.out.println("Ok");
    }

Andrew Tobilko:

Veo tres soluciones posibles:

1. returnAListOf5Elementdevuelve arr[2]dentro de la lista. (digamos de let, por contacto, que es el último elemento de la lista devuelta.) Es un enfoque sucio.

2. mapdevuelve una Map.Entry<List<Integer>, Integer>que está compuesto por el resultado de la returnAListOf5Element(...)llamada y arr[2]. Es una manera más razonable.

Estos dos idus se basan en el almacenamiento en caché estado de una operación anterior para que pueda conseguirlo a un siguiente. Es la única manera de obtener el resultado calculado en la cadena antes.

3. Que sustituya la cadena corriente con un simple bucle donde cada cálculo intermedio es accesible.

Me parece que el último método más simple y en cuanto al rendimiento. No parece que se va a cosechar los beneficios de las corrientes de aquí. Me se pegaba a ella.