Comment puis-je extraire ArrayList à partir de HashMap et le boucler en Java? Je

Question

ont mis en place un HashMap comme ceci:

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

... et je remplir en stockant pour chaque nom (clé), une liste de noms (valeur). Alors:

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

Alors maintenant, je veux regarder à travers toutes les entrées de la table de hachage et de voir si (pour chaque « sAccuser »), la liste « saAccused » contient un certain nom. Ceci est ma tentative a échoué jusqu'à présent:

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(); 
} 

... mais je ne sais pas comment les classes Set et Iterator travail:/Le problème est que je n'ai pas les « valeurs » ... la noms ... le 'sAccuser' s ... pour le HashMap disponible. En un mot, je veux parcourir la HashMap et vérifier si un nom spécifique est stocké dans l'une des listes. Alors, comment puis-je faire cela? Faites-moi savoir si vous avez besoin de moi pour approfondir les détails ou dissiper toute confusion.

Merci.

Answer 1

En un mot, je veux parcourir la HashMap et vérifier si un nom spécifique est stocké dans l'une des listes. Alors, comment puis-je faire cela?

Il existe deux façons de parcourir la carte qui pourraient vous intéresser ici. Premièrement, vous pouvez parcourir tous les mappages (c'est-à-dire les paires de relations clé-valeur) en utilisant la méthode entrySet(), qui vous permettra de savoir quelle est la clé de chaque liste d'arrays. Sinon, si vous n'avez pas besoin de la clé, vous pouvez simplement obtenir toutes les listes à leur tour via la méthode values(). En utilisant la première option pourrait ressembler à ceci:

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 
    } 
} 

Pour répondre aux questions plus larges - l'interface Set représente simplement une (non numérotée) collection de valeurs non-double. Comme vous pouvez le voir par le Javadoc lié, il existe des méthodes disponibles que vous pourriez attendre pour une telle collection non ordonnée. Un Iterator est un objet qui traverse une structure de données présentant successivement chaque élément.L'utilisation typique d'un itérateur ressemblerait à quelque chose comme ce qui suit:

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 
} 

qui est, vérifier si l'itérateur est nonexhausted (a plus d'éléments), puis appeler la méthode next() pour obtenir cet élément. Cependant, puisque le modèle ci-dessus est si commun, il peut être élidé avec foreach loop de Java 5, vous épargnant de traiter avec l'itérateur lui-même, comme j'en ai profité dans mon premier exemple.

Answer 2

Vous devez utiliser la valeur de Iterator.next() pour indexer dans Map.

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

Actuellement vous obtenez des valeurs de la Map basées sur la iterator, pas les valeurs renvoyées par la iterator.

Answer 3

Quelque chose comme ça?

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

Answer 4

Cela devrait le faire fonctionner:

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

Cependant, pour rendre plus lisible votre code, vous pouvez soit:

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

ou, si vous avez besoin de la clé:

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

Answer 5

Faire une méthode qui le fait:

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; 
     } 
    } 
} 

Et quand vous appelez la méthode:

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

Answer 6

Il semble que vous devez faire deux choses: d'abord, savoir si un nom donné est "accusé", et deuxièmement, découvrez qui est l'accusateur. Pour cela, vous devez parcourir les objets Entrée dans votre carte.

for (Entry<String, List<String>> entry : theAccused.entrySet()) { 
     if (entry.getValue().contains(accused)) { 
      return entry.getKey(); 
     } 
    } 

    return null; // Or throw NullPointerException, or whatever. 

Dans cette boucle, l'objet Entrée contient un seul mappage de valeurs de clé. Donc entry.getValue() contient la liste des accusés, et entry.getKey() contient leur accusateur.