tengo una coleccion de la siguiente manera
Map<String, Set<Long>> myMap = new HashMap<>();Quiero saber si alguna entrada en este mapa se ha establecido que está contenida en otra entrada del mismo mapa.
Por ejemplo, digamos que el mapa tiene las siguientes 5 entradas
a - {1, 2, 3} b - {4, 5} c - {1} d - {2, 3} e - {5} f - {6}Entonces, tiene las siguientes entradas superpuestas como tal vez
a - {1, 2, 3} and c - {1} b - {4, 5} and e - {5} a - {1, 2, 3} and d - {2, 3}O simplemente una lista de Set para teclas como
a and c b and e a and dPodría iterar cada conjunto de claves y luego usar disjoint o anyMatch para cada conjunto, pero me preguntaba si hay una forma optimizada (Java 8, 9, 10, 11).
Compare la solución como bucles anidados o flujo.
Editar: redujo el código a lo que es relevante
import java.util.*; import java.util.function.BiPredicate; import java.util.stream.Collectors; class Main { public static void main(String[] args) { Map<String, Set<Long>> myMap = new HashMap<>(); myMap.put("a", Set.of( 1l, 2l, 3l )); myMap.put("b", Set.of( 4l, 5l )); myMap.put("c", Set.of( 1l )); myMap.put("d", Set.of( 2l, 3l )); myMap.put("e", Set.of( 5l )); myMap.put("f", Set.of( 6l )); Set<String> keys = myMap.keySet(); BiPredicate<String, String> condition = (a, b) -> !a.equals(b) && myMap.get(a).size() >= myMap.get(b).size() && myMap.get(a).containsAll(myMap.get(b)); // nested Loop Set<Map.Entry<String, String>> nested = new HashSet<>(); for (String a : keys) for (String b : keys) if (condition.test(a, b)) nested.add(Map.entry(a, b)); System.out.println(nested); // stream Set<Map.Entry<String, String>> collect = keys.stream() .flatMap(a -> keys.stream() .filter(b -> condition.test(a, b)) .map(b -> Map.entry(a, b))) .collect(Collectors.toSet()); System.out.println(collect); } }import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; public class Main { public static void main(String[] args) { Map<String, Set<Long>> map = new HashMap<>(); map.put("a", Set.of(1l, 2l, 3l)); map.put("b", Set.of(4l, 5l)); map.put("c", Set.of(1l)); map.put("d", Set.of(2l, 3l)); map.put("e", Set.of(5l)); map.put("f", Set.of(6l)); Set<Map.Entry<String, String>> result = map.entrySet() .stream().map( (source) -> map.entrySet().stream() .takeWhile((pair) -> pair.getValue() != source.getValue()) .filter((pair) -> pair.getValue().containsAll(source.getValue())) .map((pair) -> Map.entry(pair.getKey(), source.getKey())) ).reduce(Stream.empty(), Stream::concat).collect(Collectors.toSet()); System.out.println(result); } Primero, todo el mapa se itera y se convierte en Stream<Stream<Map.Entry<String, String>> . Por reduce(Stream.empty(), Stream::concat).collect(Collectors.toSet()); esto se convierte en el tipo de salida en el que todos los flujos se fusionan. Para obtener el Stream<Map.Entry<String, String>> individual para cada entrada en el mapa de origen, iteramos nuevamente sobre cada entrada en la lista de origen, pero esta vez takeWhile((pair) -> pair.getValue() != source.getValue()) ignora todos los valores que aún no han aparecido en el primer ciclo, evitando así resultados duplicados como (a, b) y (b, a) y también aquellos que contienen el mismo valor dos veces como (a, a ). Ahora se puede pair.getValue().containsAll(source.getValue()) para verificar si la entrada de la secuencia interna contiene la entrada de la secuencia externa y eliminarla de la secuencia si no hay coincidencia, este resultado solo entonces tiene que convertirse en Stream<Map.Entry<String, String>> , que se logra mediante map((pair) -> Map.entry(pair.getKey(), source.getKey())) .
La salida de este código es:
[a=c, a=d, b=e]