and - Hashmap con Streams en Java 8 Streams para recopilar el valor de Map

map stream java

Question

Consideremos un hashmap

Map<Integer, List> id1 = new HashMap<Integer,List>();

Inserté algunos valores en ambos hashmap.

Por ejemplo,

    List<String> list1 = new ArrayList<String>();

    list1.add("r1");
    list1.add("r4");

    List<String> list2 = new ArrayList<String>();
    list2.add("r2");
    list2.add("r5");

    List<String> list3 = new ArrayList<String>();
    list3.add("r3");
    list3.add("r6");

    id1.put(1,list1);
    id1.put(2,list2);
    id1.put(3,list3);
    id1.put(10,list2);
    id1.put(15,list3);

Q1) Ahora quiero aplicar una condición de filtro en la clave en hashmap y recuperar el valor correspondiente (Lista).

Ejemplo: aquí Mi consulta es clave = 1, y la salida debe ser ''lista1''

escribí

id1.entrySet().stream().filter( e -> e.getKey() == 1);

Pero no sé cómo recuperarlo como una lista como salida de esta operación de transmisión.

P2) Nuevamente quiero aplicar una condición de filtro en la clave en hashmap y recuperar la lista correspondiente de listas.

Por ejemplo: Aquí Mi consulta es clave = 1% (es decir, la clave puede ser 1,10,15), y la salida debe ser ''lista1'', ''lista2'', ''lista3'' (lista de listas).

Answer 1

Lo que debe hacer es crear un Stream del .entrySet() ''s .entrySet() :

// Map<K, V> --> Set<Map.Entry<K, V>> --> Stream<Map.Entry<K, V>>
map.entrySet().stream()

Desde el .filter() , puede .filter() sobre estas entradas. Por ejemplo:

// Stream<Map.Entry<K, V>> --> Stream<Map.Entry<K, V>>
.filter(entry -> entry.getKey() == 1)

Y para obtener los valores del mismo, usted .map() :

// Stream<Map.Entry<K, V>> --> Stream<V>
.map(Map.Entry::getValue)

Finalmente, debe recopilar en una List :

// Stream<V> --> List<V>
.collect(Collectors.toList())

Si solo tiene una entrada, utilícela en su lugar (NOTA: este código supone que hay un valor; de lo contrario, use .orElse() ; consulte el javadoc de Optional para obtener más detalles):

// Stream<V> --> Optional<V> --> V
.findFirst().get()

Answer 2

Para su Q2, ya hay respuestas a su pregunta. Para su Q1, y más generalmente cuando sabe que el filtrado de la clave debe dar un valor único, no es necesario usar Streams en absoluto.

Simplemente use get o getOrDefault , es decir:

List<String> list1 = id1.getOrDefault(1, Collections.emptyList());

Answer 3

Si está seguro de que obtendrá como máximo un único elemento que pasó el filtro (que está garantizado por su filtro), puede utilizar findFirst :

Optional<List> o = id1.entrySet()
                      .stream()
                      .filter( e -> e.getKey() == 1)
                      .map(Map.Entry::getValue)
                      .findFirst();

En el caso general, si el filtro puede coincidir con múltiples listas, puede recopilarlas en una lista de listas:

List<List> list = id1.entrySet()
                     .stream()
                     .filter(.. some predicate...)
                     .map(Map.Entry::getValue)
                     .collect(Collectors.toList());

Answer 4

También puedes hacerlo así

public Map<Boolean, List<Student>> getpartitionMap(List<Student> studentsList) {

    List<Predicate<Student>> allPredicates = getAllPredicates();
    Predicate<Student> compositePredicate =  allPredicates.stream()
                             .reduce(w -> true, Predicate::and)
     Map<Boolean, List<Student>> studentsMap= studentsList
                .stream()
                .collect(Collectors.partitioningBy(compositePredicate));
    return studentsMap;
}

public List<Student> getValidStudentsList(Map<Boolean, List<Student>> studentsMap) throws Exception {

    List<Student> validStudentsList =  studentsMap.entrySet()
             .stream()
             .filter(p -> p.getKey() == Boolean.TRUE)
             .flatMap(p -> p.getValue().stream())
             .collect(Collectors.toList());

    return validStudentsList;
}

public List<Student> getInValidStudentsList(Map<Boolean, List<Student>> studentsMap) throws Exception {

    List<Student> invalidStudentsList = 
             partionedByPredicate.entrySet()
             .stream()
             .filter(p -> p.getKey() == Boolean.FALSE)
             .flatMap(p -> p.getValue().stream())
             .collect(Collectors.toList());

    return invalidStudentsList;

}

Con flatMap obtendrá solo List<Student> lugar de List<List<Student>> .

Gracias