¿Cómo puedo extraer ArrayList de HashMap y recorrerlo en Java?

Question

que han establecido un HashMap así:

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

... y poblar esto almacenando para cada nombre (clave), una lista de nombres (valor). Por lo tanto:

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

Así que ahora, quiero mirar a través de todas las entradas en el HashMap y ver si (para cada 'sAccuser'), la lista 'saAccused' contiene un cierto nombre. Este es mi intento fracasado hasta ahora:

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

... sin embargo no estoy seguro de cómo funcionan los Set y Iterator clases:/El problema es que no tengo los "valores" ... el nombres ... 'sAccuser' s ... para el HashMap disponible.

En pocas palabras, quiero iterar a través del HashMap y verificar si un nombre específico está almacenado en cualquiera de las listas. Entonces, ¿cómo puedo hacer esto? Avíseme si necesita que entre más detalles o aclare cualquier confusión.

Gracias.

Answer 1

En pocas palabras, quiero iterar a través del HashMap y verificar si un nombre específico está almacenado en cualquiera de las listas. Entonces, ¿cómo puedo hacer esto?

Hay dos formas de recorrer el mapa que pueden ser de interés aquí. En primer lugar, puede iterar a través de todas las asignaciones (es decir, pares de relaciones clave-valor) utilizando el método entrySet(), que le permitirá saber cuál es la clave para cada lista de arrays. Alternativamente, si no necesita la clave, simplemente puede obtener todas las listas a su vez a través del método values(). Utilizando la primera opción podría ser algo como esto:

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

para responder las preguntas más amplias - la interfaz Set representa simplemente una colección (no ordenado) de valores no duplicadas. Como puede ver en el Javadoc vinculado, hay métodos disponibles que podría esperar para una colección desordenada. Un Iterator es un objeto que atraviesa una estructura de datos que presenta cada elemento sucesivamente.El uso típico de un iterador sería algo como lo siguiente:

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 
} 

es decir, comprobar si se nonexhausted el iterador (tiene más elementos) a continuación, llamar al método next() para conseguir ese elemento. Sin embargo, dado que el patrón anterior es tan común, se puede elidir con el foreach loop de Java 5, evitando que se ocupe del iterador mismo, como aproveché en mi primer ejemplo.

Answer 2

Debe utilizar el valor de Iterator.next() para indexar en el Map.

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

valores Actualmente se está recibiendo de la Map basan en el iterador , no los valores devueltos por el iterador.

Answer 3

¿Algo como esto?

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

Answer 4

Esto debería hacer que funcione:

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

Sin embargo, para que su código sea más legible, puede tener:

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

o, si necesita la clave:

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

Answer 5

Hacer un método que lo hace:

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

Y cuando se llama al método:

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

Answer 6

Suena como que tiene que hacer dos cosas: en primer lugar, averiguar si un nombre dado es "acusado", y segundo, descubre quién es el acusador. Para eso, necesita iterar sobre los objetos de Entrada dentro de su Mapa.

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

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

En este bucle, el objeto Entry tiene una sola correlación de valores-clave. Entonces entry.getValue() contiene la lista de acusados, y entry.getKey() contiene su acusador.