Wie kann ich ArrayList aus HashMap extrahieren und in Java durchlaufen?

Question

Ich habe eine HashMap wie folgt eingerichtet:

Map<String, ArrayList<String>> theAccused = new HashMap<String, ArrayList<String>>(); 

... und ich befülle dies, indem ich für jeden Namen (Schlüssel) eine Liste von Namen (Wert) hinterlege. Also:

ArrayList<String> saAccused = new ArrayList<String>(); 
// populate 'saAccused' ArrayList 
... 
// done populating 
theAccused.put(sAccuser, saAccused); 

Also jetzt möchte ich durch alle Einträge in der HashMap schauen und sehen, ob (für jeden 'sAccuser') die Liste 'saAccused' einen bestimmten Namen enthält. Das ist mein gescheiterter Versuch bisher:

Set<String> setAccusers = theAccused.keySet(); 
Iterator<String> iterAccusers = setAccusers.iterator(); 
iterAccusers.next(); 
ArrayList<String> saTheAccused; 

// check if 'sAccuser' has been accused by anyone before 
for (int i = 0; i < theAccused.size(); i++) { 
    saTheAccused = theAccused.get(iterAccusers); 

    if (saTheAccused.contains(sAccuser)) { 

    } 
    iterAccusers.next(); 
} 

... aber ich bin mir nicht sicher, wie die Set- und Iterator-Klassen funktionieren:/Das Problem ist, dass ich die "Werte" nicht habe ... Namen ... die 'sAccuser' s ... für die HashMap verfügbar.

Kurz gesagt, ich möchte die HashMap durchlaufen und prüfen, ob ein bestimmter Name in einer der Listen gespeichert ist. Wie kann ich das tun? Lassen Sie es mich wissen, wenn Sie mich brauchen, um näher ins Detail zu gehen oder Verwirrung zu beseitigen.

Danke.

Answer 1

Kurz gesagt, ich möchte die HashMap durchlaufen und prüfen, ob ein bestimmter Name in einer der Listen gespeichert ist. Wie kann ich das tun?

Es gibt zwei Möglichkeiten, die Karte zu durchlaufen, die hier von Interesse sein könnten. Erstens können Sie alle Zuordnungen (d. H. Paare von Schlüssel/Wert-Beziehungen) unter Verwendung der entrySet()-Methode durchlaufen, wodurch Sie wissen, was der Schlüssel für jede Arraylist ist. Alternativ, wenn Sie den Schlüssel nicht benötigen, können Sie einfach alle Listen nacheinander über die Methode values() abrufen. Mit der ersten Option könnte wie folgt aussehen:

for (Map.Entry<String, ArrayList<String>> entry : theAccused.entrySet()) 
{ 
    String sListName = entry.getKey(); 
    ArrayList<String> saAccused = entry.getValue(); 
    if (saAccused.contains(sAccuser)) 
    { 
     // Fire your logic for when you find a match, which can 
     // depend on the list's key (name) as well 
    } 
} 

die breiteren Fragen zu beantworten - die Set Schnittstelle einfach stellt eine (ungeordnete) Sammlung von nicht-duplizierte Werten. Wie Sie dem verknüpften Javadoc entnehmen können, gibt es Methoden, die Sie für eine solche ungeordnete Sammlung erwarten könnten. Ein Iterator ist ein Objekt, das eine Datenstruktur durchläuft, die wiederum jedes Element darstellt.Typische Verwendung eines Iterators aussehen würde, etwa wie folgt:

Iterator<?> it = ...; // get the iterator somehow; often by calling iterator() on a Collection 
while (it.hasNext()) 
{ 
    Object obj = it.next(); 
    // Do something with the obj 
} 

das heißt, überprüfen, ob der Iterator nonexhausted (mehr Elemente hat), dann rufen Sie die next() Methode, dieses Element zu erhalten. Da das obige Muster jedoch so häufig ist, kann es mit foreach loop von Java 5 verglichen werden, so dass Sie nicht mit dem Iterator selbst arbeiten müssen, wie ich in meinem ersten Beispiel ausgenutzt habe.

Answer 2

Sie müssen den Wert von Iterator.next() verwenden, um in die Map zu indizieren.

String key = iterAccusers.next(); 
saTheAccused = theAccused.get(key); 

Derzeit Sie bekommen Werte aus dem Map basierend auf dem Iterator, nicht die von der Iterator zurückgegebenen Werte.

Answer 3

So ähnlich?

saTheAccused = theAccused.get(iterAccused.next()); 

jedoch der Code besser lesbar zu machen, können Sie entweder:

for (List<String> list : theAccused.values()) { 
    if (list.contains("somename")) { 
     // found somename 
    } 
} 

Answer 4

Dies sollte es funktioniert

for (List<String> values : theAccused.values()) { 
    if (value.contains(sAcuser)) { 
     .. 
    } 
} 

oder, wenn Sie den Schlüssel brauchen:

for (String key : theAccused.keySet()) { 
    List<String> accused = theAccused.get(key); 
    if (accused.contains(sAccuser)) { 
    } 
} 

Answer 5

eine Methode machen, dass es funktioniert:

private String findListWithKeyword(Map<String, ArrayList<String>> map, String keyword) { 
    Iterator<String> iterAccusers = map.keySet().iterator(); 
    while(iterAccusers.hasNext()) { 
     String key = iterAccusers.next(); 
     ArrayList<String> list = theAccused.get(key); 
     if (list.contains(keyword)) { 
     return key; 
     } 
    } 
} 

Und wenn Sie die Methode aufrufen:

String key = findListWithKeyword(map, "foobar"); 
ArrayList<String> theCorrectList = map.get(key); 

Answer 6

Es klingt wie Sie zwei Dinge tun müssen: Erstens, herauszufinden, ob ein bestimmter Name ist "angeklagt", und zweitens, finden Sie heraus, wer der Ankläger ist. Dazu müssen Sie über die Entry-Objekte in Ihrer Map iterieren.

In dieser Schleife enthält das Entry-Objekt eine einzelne Schlüsselwertzuordnung. So enthält entry.getValue() die Liste von Angeklagten, und entry.getKey() enthält ihren Ankläger.