¿Cómo filtrar un mapa por sus valores en Java 8?

Tengo un mapa donde los valores son cadenas y las claves son listas:

Map<String, List<BoMLine>> materials

Me gustaría filtrar este mapa por sus valores; algo como esto:

materials.entrySet().stream()
       .filter(a -> a.getValue().stream()
           .filter(l -> MaterialDao.findMaterialByName(l.getMaterial()).ispresent)

Pero no está funcionando para mí. Alguien tiene una idea?

Si entiendo correctamente sus criterios de filtrado, desea verificar si el filtrado Stream usted produjo a partir del valor List tiene algún elemento, y en caso afirmativo pasar el correspondiente Map entrada a la salida Map.

Map<String, List<BoMLine>>
    filtered = materials.entrySet()
                        .stream()
                        .filter(a->a.getValue()
                                    .stream()
                                    .anyMatch(l->MaterialDao.findMaterialByName(l.getMaterial())))
                        .collect(Collectors.toMap(e->e.getKey(),e->e.getValue()));

esto es asumiendo MaterialDao.findMaterialByName(l.getMaterial()) devuelve un boolean.

Generalmente, así es como puede filtrar un mapa por sus valores:

static <K, V> Map<K, V> filterByValue(Map<K, V> map, Predicate<V> predicate) {
    return map.entrySet()
            .stream()
            .filter(entry -> predicate.test(entry.getValue()))
            .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
}

Llámalo así:

Map<String, Integer> originalMap = new HashMap<>();
originalMap.put("One", 1);
originalMap.put("Two", 2);
originalMap.put("Three", 3);

Map<String, Integer> filteredMap = filterByValue(originalMap, value -> value == 2);

Map<String, Integer> expectedMap = new HashMap<>();
expectedMap.put("Two", 2);

assertEquals(expectedMap, filteredMap);

Todas las respuestas anteriores proporcionan una solución que crea una nueva Map. Esto puede ser ineficaz si desea eliminar solo unas pocas entradas.

Lo siguiente elimina los elementos de la existente Map:

Map<String, Integer> myMap = new HashMap<>();
myMap.put("One", 1);
myMap.put("Two", 2);
myMap.put("Three", 3);

myMap.keySet().removeAll(
        myMap.entrySet().stream()
           .filter(a->a.getValue().equals(2))
                   .map(e -> e.getKey()).collect(Collectors.toList()));

System.out.println(myMap);

Huellas dactilares:

{One=1, Three=3}

¿Como funciona? Recoge todo llaves que necesitan ser removidos en un temporal Listluego los elimina del original Map en una ida. Un temporal List es necesario porque la modificación de un Map invalida flujos e iteradores. Sin embargo, la construcción de un nuevo Map es potencialmente una operación mucho más costosa que construir un List.

Si desea eliminar muchas entradas (50% o más), entonces es mejor crear una nueva Map en efecto.

Finalmente lo hice funcionar. Mi segundo filtro fue completamente inútil. La respuesta es así:

Map<String, List<BoMLine>>
filtered = materials.entrySet()
                    .stream()
                    .filter(a -> a
                      .getValue()
                       .stream()
                        .allMatch(
                            b -> MaterialDao.findMaterialByName(
                                    b.getMaterial()).isPresent()))
            .collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()))

En mi humilde opinión, uno de los códigos Java 8 más concisos puede verse así:

public Map<String, ReportPlaceholderValue> getAllPlaceholders() {
    Map<String, ReportPlaceholderValue> result = chamberDetailsPlaceHolders;

    result.entrySet().stream().filter( e -> !(e.getValue() instanceof StringReportPlaceholderValue) )
       .map( Map.Entry::getKey )
       .collect( Collectors.toList() ).forEach( result.keySet()::remove );

    return result;
}