las formas posibles a escribir a continuación el código en Java 8

Mayank Bisht:

Tengo un código, que está trabajando como se requiere, pero quiero volver a escribir en Java 8.


Este código producirá un elemento de lista map.Each quiere que todos los servidores asignados a la misma.

public static Map<String, List<String>> agg(){
        List<String> list = Arrays.asList("Item A", "Item B", "Item C");
        List<String> servers = Arrays.asList("Server A", "Server B", "Server C", "Server D");
        Map<String, List<String>> map = new HashMap<>();
        for (int i = 0; i < list.size(); i++) {
            ArrayList<String> temp = new ArrayList<>();
            for (int j = 0; j < servers.size(); j++) {
                temp.add(servers.get(j));
            }
            map.put(list.get(i), temp);
        }
        return map;
    }

Salida

Item C ::[Server A, Server B, Server C, Server D]
Item B ::[Server A, Server B, Server C, Server D]
Item A ::[Server A, Server B, Server C, Server D]

Lo que sería el equivalente lambda?

nucandrei:

código simplificar Vamos antes de convertirlo en expresiones lambda

 public static Map<String, List<String>> agg(){
    List<String> list = Arrays.asList("Item A", "Item B", "Item C");
    List<String> servers = Arrays.asList("Server A", "Server B", "Server C", "Server D");
    Map<String, List<String>> map = new HashMap<>();
    for (int i = 0; i < list.size(); i++) {
        map.put(list.get(i), new ArrayList<>(servers));
    }
    return map;
}

Yo sólo simplificado la creación de una copia matriz.

La tubería de convertir de una forma de datos a otro en Java 8 contiene los siguientes pasos:

1. corriente
2. mapa (convertir de una forma a otra)
3. reducir (filtrar valores no deseados)
4. (resultados de cobro revertido) recopilar

Debido a que los datos no necesitan ser convertidos, simplemente recogido en una estructura diferente, mapa y reducir no son necesarios

public static Map<String, List<String>> agg(){
    List<String> list = Arrays.asList("Item A", "Item B", "Item C");
    List<String> servers = Arrays.asList("Server A", "Server B", "Server C", "Server D");

    Function<String, String> keyFunction = key -> key;
    Function<String, List<String>> valueFunction = key -> new ArrayList<>(servers);

    return list.stream()
            .collect(Collectors.toMap(keyFunction, valueFunction));
}

Estas funciones pueden ser inline y el resultado sería:

    public static Map<String, List<String>> agg(){
    List<String> list = Arrays.asList("Item A", "Item B", "Item C");
    List<String> servers = Arrays.asList("Server A", "Server B", "Server C", "Server D");

    return list.stream()
            .collect(Collectors.toMap(key -> key, key -> new ArrayList<>(servers)));
}