Przekształcanie i filtrowanie mapy Java ze strumieniami

Question

Mam mapę Java, którą chcę przekształcić i przefiltrować. Jako trywialny przykład załóżmy, że chcę przekonwertować wszystkie wartości na liczby całkowite, a następnie usunąć nieparzyste wpisy.

Map<String, String> input = new HashMap<>(); 
input.put("a", "1234"); 
input.put("b", "2345"); 
input.put("c", "3456"); 
input.put("d", "4567"); 

Map<String, Integer> output = input.entrySet().stream() 
     .collect(Collectors.toMap(
       Map.Entry::getKey, 
       e -> Integer.parseInt(e.getValue()) 
     )) 
     .entrySet().stream() 
     .filter(e -> e.getValue() % 2 == 0) 
     .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); 


System.out.println(output.toString()); 

ta jest poprawna, a rentowności: {a=1234, c=3456}

Niestety, nie mogę pomóc, ale zastanawiam się, czy istnieje sposób, aby uniknąć wywoływania .entrySet().stream() dwukrotnie.

Czy jest sposób, w jaki mogę wykonać operacje transformacji i filtrowania i zadzwonić pod numer .collect() tylko raz na końcu?

Answer 1

Tak, możesz odwzorować każdy wpis na inny tymczasowy wpis, w którym będzie przechowywany klucz i przeanalizowana liczba całkowita. Następnie możesz filtrować każdy wpis na podstawie jego wartości.

Map<String, Integer> output = 
    input.entrySet() 
     .stream() 
     .map(e -> new AbstractMap.SimpleEntry<>(e.getKey(), Integer.valueOf(e.getValue()))) 
     .filter(e -> e.getValue() % 2 == 0) 
     .collect(Collectors.toMap(
      Map.Entry::getKey, 
      Map.Entry::getValue 
     )); 

Zauważ, że użyłem Integer.valueOf zamiast parseInt ponieważ rzeczywiście chcemy pudełkowej int.

---

Jeśli masz luksus korzystania z biblioteki StreamEx, można to zrobić bardzo prosto:

Map<String, Integer> output = 
    EntryStream.of(input).mapValues(Integer::valueOf).filterValues(v -> v % 2 == 0).toMap(); 

Answer 2

Można użyć metody Stream.collect(supplier, accumulator, combiner) przekształcać wpisy i warunkowo gromadzić je:

Map<String, Integer> even = input.entrySet().stream().collect(
    HashMap::new, 
    (m, e) -> Optional.ofNullable(e) 
      .map(Map.Entry::getValue) 
      .map(Integer::valueOf) 
      .filter(i -> i % 2 == 0) 
      .ifPresent(i -> m.put(e.getKey(), i)), 
    Map::putAll); 

System.out.println(even); // {a=1234, c=3456} 

Tutaj, wewnątrz akumulatora, używam metod Optional do zastosowania zarówno transformacji, jak i predykatu, a także opcjonalnego v alue jest nadal obecny, dodaję go do zebranej mapy.

Answer 3

Innym sposobem, aby to zrobić, to usunąć wartości, których nie chcesz z przekształconej Map:

Map<String, Integer> output = input.entrySet().stream() 
     .collect(Collectors.toMap(
       Map.Entry::getKey, 
       e -> Integer.parseInt(e.getValue()), 
       (a, b) -> { throw new AssertionError(); }, 
       HashMap::new 
     )); 
output.values().removeIf(v -> v % 2 != 0); 

Zakłada chcesz zmienny Map jako wynik, jeśli nie prawdopodobnie można utworzyć niezmienna jeden z output.

---

Jeśli przekształcenia wartości do tego samego typu i chcesz zmodyfikować Map w miejscu, to może być dużo krótsza z replaceAll:

input.replaceAll((k, v) -> v + " example"); 
input.values().removeIf(v -> v.length() > 10); 

zakłada to również input jest zmienny.

---

Nie polecam ten sposób, ponieważ nie będzie działać na wszystkich ważnych Map wdrożeń i może przestać działać na HashMap w przyszłości, ale obecnie można używać replaceAll i rzucić HashMap zmienić typ wartości:

((Map)input).replaceAll((k, v) -> Integer.parseInt((String)v)); 
Map<String, Integer> output = (Map)input; 
output.values().removeIf(v -> v % 2 != 0); 

będzie to również dać wpisać zasadami bezpieczeństwa i jeśli starają się odzyskać wartość z Map poprzez odniesienie starego typu jak ten:

String ex = input.get("a"); 

Spowoduje to wyświetlenie ClassCastException.

---

Można przesunąć pierwszy przekształcić część do metody, aby uniknąć boilerplate jeśli można oczekiwać, aby go używać dużo:

public static <K, VO, VN, M extends Map<K, VN>> M transformValues(
     Map<? extends K, ? extends VO> old, 
     Function<? super VO, ? extends VN> f, 
     Supplier<? extends M> mapFactory){ 
    return old.entrySet().stream().collect(Collectors.toMap(
      Entry::getKey, 
      e -> f.apply(e.getValue()), 
      (a, b) -> { throw new IllegalStateException("Duplicate keys for values " + a + " " + b); }, 
      mapFactory)); 
} 

i używać go tak:

Map<String, Integer> output = transformValues(input, Integer::parseInt, HashMap::new); 
    output.values().removeIf(v -> v % 2 != 0); 

Uwaga że wyjątek klucza duplikatu może zostać zgłoszony, jeśli na przykład oldMap jest IdentityHashMap i mapFactory tworzy HashMap.

Answer 4

Jednym ze sposobów rozwiązania problemu z dużo mniejszym obciążeniem jest przesunięcie mapowania i filtrowanie do kolektora.

Map<String, Integer> output = input.entrySet().stream().collect(
    HashMap::new, 
    (map,e)->{ int i=Integer.parseInt(e.getValue()); if(i%2==0) map.put(e.getKey(), i); }, 
    Map::putAll); 

nie wymaga tworzenia pośrednich Map.Entry przypadkach, a nawet lepiej, będzie odłożyć boks z int wartości do momentu, gdy wartości te są faktycznie dodanej do Map, co oznacza, że ​​wartości odrzucone przez filtr są w ogóle nie zapakowane.

W porównaniu do tego, co robi Collectors.toMap(…), operacja jest również uproszczona przez użycie Map.put zamiast Map.merge jak wiemy z góry, że nie mamy do obsługi kluczowych kolizji tutaj.

Jednak tak długo, jak nie chcesz wykorzystać wykonanie równoległego można również rozważyć zwykłą pętlę

HashMap<String,Integer> output=new HashMap<>(); 
for(Map.Entry<String, String> e: input.entrySet()) { 
    int i = Integer.parseInt(e.getValue()); 
    if(i%2==0) output.put(e.getKey(), i); 
} 

lub wewnętrzny wariant iteracji:

HashMap<String,Integer> output=new HashMap<>(); 
input.forEach((k,v)->{ int i = Integer.parseInt(v); if(i%2==0) output.put(k, i); }); 

ten ostatni jest dość zwarta i co najmniej na równi ze wszystkimi innymi wariantami dotyczącymi wydajności z pojedynczym gwintem.

Answer 5

Guava jest twoim przyjacielem:

Map<String, Integer> output = Maps.filterValues(Maps.transformValues(input, Integer::valueOf), i -> i % 2 == 0); 

Należy pamiętać, że output jest przekształcona, sączy widok od input. Musisz wykonać kopię, jeśli chcesz działać na nich niezależnie.

Answer 6

Oto kod przez AbacusUtil

Map<String, String> input = N.asMap("a", "1234", "b", "2345", "c", "3456", "d", "4567"); 

Map<String, Integer> output = Stream.of(input) 
          .groupBy(e -> e.getKey(), e -> N.asInt(e.getValue())) 
          .filter(e -> e.getValue() % 2 == 0) 
          .toMap(Map.Entry::getKey, Map.Entry::getValue); 

N.println(output.toString()); 

Deklaracji: Jestem deweloperem AbacusUtil.