Java 8 extrahiere ersten Schlüssel von passendem Wert in einer Karte

Question

Angenommen, ich habe eine Karte mit Vornamen, Nachnamen und möchte den Vornamen des ersten Eintrags in dieser Karte finden, der den Nachnamen mit einem bestimmten Wert hat. Wie würden wir das in einer Java 8 Mode machen.

In meinem Testfall Beispiel unten habe ich zwei Möglichkeiten, die es tun würde.

Die erste (Suche nach dem Vornamen der ersten Person mit dem Nachnamen "Donkey") wird java.util.NoSuchElementException werfen: Kein Wert vorhanden, so dass es nicht sicher ist.

Die zweite funktioniert, aber es ist nicht nur schwieriger zu lesen, aber es ist ein bisschen nicht ganz funktionsfähig.

Ich frage mich nur, ob jemand hier mir einen einfacheren, klareren Weg vorschlagen würde, dies entweder mit stream() oder forEach() oder beidem zu erreichen.

@Test 
public void shouldBeAbleToReturnTheKeyOfTheFirstMatchingValue() throws Exception { 
    Map<String, String> names = new LinkedHashMap<>(); 
    names.put("John", "Doe"); 
    names.put("Fred", "Flintstone"); 
    names.put("Jane", "Doe"); 
    String keyOfTheFirst = names.entrySet().stream().filter(e -> e.getValue().equals("Doe")).findFirst().get().getKey(); 
    assertEquals("John", keyOfTheFirst); 

    try { 
     names.entrySet().stream().filter(e -> e.getValue().equals("Donkey")).findFirst().get(); 
    } catch (NoSuchElementException e){ 
     // Expected 
    } 

    Optional<Map.Entry<String, String>> optionalEntry = names.entrySet().stream().filter(e -> e.getValue().equals("Donkey")).findFirst(); 
    keyOfTheFirst = optionalEntry.isPresent() ? optionalEntry.get().getKey() : null; 

    assertNull(keyOfTheFirst); 
} 

Vielen Dank im Voraus.

Answer 1

einen Standardwert zurück, wenn es keine Übereinstimmung gibt, verwenden Optional#orElse

names.entrySet().stream() 
    .filter(e -> e.getValue().equals("Donkey")) 
    .map(Map.Entry::getKey) 
    .findFirst() 
    .orElse(null); 

Answer 2

Von einem ähnlichen question:

public static <T, E> Set<T> getKeysByValue(Map<T, E> map, E value) { 
    return map.entrySet() 
       .stream() 
       .filter(entry -> Objects.equals(entry.getValue(), value)) 
       .map(Map.Entry::getKey) 
       .collect(Collectors.toSet()); 
} 

Dann können Sie die erste wählen, wenn Sie möchten. Denken Sie daran, dass die key ist einzigartig, die value ist nicht.

Edit: Der gesamte Code (Danke @ Peter Lawrey)

package test; 

import java.util.LinkedHashMap; 
import java.util.Map; 
import java.util.Objects; 
import java.util.Optional; 

public class Main { 

    public static void main(String[] args) { 
     Map<String, String> names = new LinkedHashMap<>(); 
     names.put("John", "Doe"); 
     names.put("Fred", "Flintstone"); 
     names.put("Jane", "Doe"); 

     Optional<String> firstKey = names.entrySet().stream() 
       .filter(entry -> Objects.equals(entry.getValue(), "Doe")) 
       .map(Map.Entry::getKey).findFirst(); 

     if (firstKey.isPresent()) { 
      System.out.println(firstKey.get()); 
     } 
    } 
} 

Answer 3

Ich mag altmodisch:

static <K, V> K findFirstKeyByValue(Map<K, V> map, String value) { 
    for (Entry<K, V> e : map.entrySet()) 
     if (e.getValue().equals(value)) 
      return e.getKey(); 
    return null; 
} 

Answer 4

Die Lösung von @Misha ist die beste, wenn Sie dies tun nicht den Code von Drittanbietern verwenden möchten. My library hat die spezielle Shortcut-Methode ofKeys für solche Fälle als ich entdeckte, dass es ziemlich gemeinsame Aufgabe:

StreamEx.ofKeys(names, "Donkey"::equals).findFirst().orElse(null);