Obtenga claves de HashMap en Java

Tengo un Hashmap en Java como este:

private Map<String, Integer> team1 = new HashMap<String, Integer>();

Luego lo lleno así:

team1.put("United", 5);

¿Cómo puedo obtener las llaves? Algo así como: team1.getKey()volver "Unidos".

UNA HashMap contiene más de una clave. Puede usar keySet()para obtener el conjunto de todas las claves.

team1.put("foo", 1);
team1.put("bar", 2);

se almacenará 1con llave "foo"y2 con llave "bar". Para iterar sobre todas las claves:

for ( String key : team1.keySet() ) {
    System.out.println( key );
}

imprimirá "foo"y "bar".

Esto es factible, al menos en teoría, si conoce el índice:

System.out.println(team1.keySet().toArray()[0]);

keySet() devuelve un conjunto, por lo que convierte el conjunto en una matriz.

El problema, por supuesto, es que un conjunto no promete mantener su pedido. Si solo tiene un elemento en su HashMap, es bueno, pero si tiene más que eso, es mejor recorrer el mapa, como lo han hecho otras respuestas.

Mira esto.

https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html

(Úselo java.util.Objects.equalsporque HashMap puede contenernull )

Usando JDK8 +

/**
 * Find any key matching a value.
 *
 * @param value The value to be matched. Can be null.
 * @return Any key matching the value in the team.
 */
private Optional<String> getKey(Integer value){
    return team1
        .entrySet()
        .stream()
        .filter(e -> Objects.equals(e.getValue(), value))
        .map(Map.Entry::getKey)
        .findAny();
}

/**
 * Find all keys matching a value.
 *
 * @param value The value to be matched. Can be null.
 * @return all keys matching the value in the team.
 */
private List<String> getKeys(Integer value){
    return team1
        .entrySet()
        .stream()
        .filter(e -> Objects.equals(e.getValue(), value))
        .map(Map.Entry::getKey)
        .collect(Collectors.toList());
}

Más "genérico" y lo más seguro posible

/**
 * Find any key matching the value, in the given map.
 *
 * @param mapOrNull Any map, null is considered a valid value.
 * @param value     The value to be searched.
 * @param <K>       Type of the key.
 * @param <T>       Type of the value.
 * @return An optional containing a key, if found.
 */
public static <K, T> Optional<K> getKey(Map<K, T> mapOrNull, T value) {
    return Optional.ofNullable(mapOrNull).flatMap(map -> map.entrySet()
            .stream()
            .filter(e -> Objects.equals(e.getValue(), value))
            .map(Map.Entry::getKey)
            .findAny());
}

O si estás en JDK7.

private String getKey(Integer value){
    for(String key : team1.keySet()){
        if(Objects.equals(team1.get(key), value)){
            return key; //return the first found
        }
    }
    return null;
}

private List<String> getKeys(Integer value){
   List<String> keys = new ArrayList<String>();
   for(String key : team1.keySet()){
        if(Objects.equals(team1.get(key), value)){
             keys.add(key);
      }
   }
   return keys;
}

Puede recuperar toda la Mapllaves 's utilizando el método keySet(). Ahora, si lo que necesita es obtener una clave dado su valor , ese es un asunto completamente diferente y Mapno lo ayudará allí; necesitaría una estructura de datos especializada, comoBidiMap (un mapa que permita la búsqueda bidireccional entre clave y valores) de las Colecciones de Apache's Commons , también tenga en cuenta que varias claves diferentes podrían asignarse al mismo valor.

Como desea obtener un argumento ( United) para el que se proporciona el valor ( 5), también puede considerar el uso de un mapa bidireccional (por ejemplo, proporcionado por Guava: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google /common/collect/BiMap.html ).

Si solo necesita algo simple y más de una verificación.

public String getKey(String key)
{
    if(map.containsKey(key)
    {
        return key;
    }
    return null;
}

Luego puede buscar cualquier clave.

System.out.println( "Does this key exist? : " + getKey("United") );

private Map<String, Integer> _map= new HashMap<String, Integer>();
Iterator<Map.Entry<String,Integer>> itr=  _map.entrySet().iterator();
                //please check 
                while(itr.hasNext())
                {
                    System.out.println("key of : "+itr.next().getKey()+" value of      Map"+itr.next().getValue());
                }

Utilice la operación funcional para una iteración más rápida.

team1.keySet().forEach((key) -> { System.out.println(key); });

Una solución puede ser, si conoce la posición de la clave, convertir las claves en una matriz de cadenas y devolver el valor en la posición:

public String getKey(int pos, Map map) {
    String[] keys = (String[]) map.keySet().toArray(new String[0]);

    return keys[pos];
}

Prueba este sencillo programa:

public class HashMapGetKey {

public static void main(String args[]) {

      // create hash map

       HashMap map = new HashMap();

      // populate hash map

      map.put(1, "one");
      map.put(2, "two");
      map.put(3, "three");
      map.put(4, "four");

      // get keyset value from map

Set keyset=map.keySet();

      // check key set values

      System.out.println("Key set values are: " + keyset);
   }    
}

public class MyHashMapKeys {

    public static void main(String a[]){
        HashMap<String, String> hm = new HashMap<String, String>();
        //add key-value pair to hashmap
        hm.put("first", "FIRST INSERTED");
        hm.put("second", "SECOND INSERTED");
        hm.put("third","THIRD INSERTED");
        System.out.println(hm);
        Set<String> keys = hm.keySet();
        for(String key: keys){
            System.out.println(key);
        }
    }
}

Para obtener claves en HashMap, tenemos el método keySet () que está presente en el java.util.Hashmappaquete. ex:

Map<String,String> map = new Hashmap<String,String>();
map.put("key1","value1");
map.put("key2","value2");

// Now to get keys we can use keySet() on map object
Set<String> keys = map.keySet();

Ahora las claves tendrán todas sus claves disponibles en el mapa. ej .: [clave1, clave2]

Lo que haré es muy simple pero desperdiciar memoria es mapear los valores con una clave y hacer lo contrario para mapear las claves con un valor haciendo esto:

private Map<Object, Object> team1 = new HashMap<Object, Object>();

es importante que use <Object, Object>para poder mapear keys:Valuey Value:Keysasí

team1.put("United", 5);

team1.put(5, "United");

Entonces si usas team1.get("United") = 5 yteam1.get(5) = "United"

Pero si usas algún método específico en uno de los objetos en los pares, seré mejor si haces otro mapa:

private Map<String, Integer> team1 = new HashMap<String, Integer>();

private Map<Integer, String> team1Keys = new HashMap<Integer, String>();

y entonces

team1.put("United", 5);

team1Keys.put(5, "United");

y recuerda, mantenlo simple;)

Para obtener clave y su valor

p.ej

private Map<String, Integer> team1 = new HashMap<String, Integer>();
  team1.put("United", 5);
  team1.put("Barcelona", 6);
    for (String key:team1.keySet()){
                     System.out.println("Key:" + key +" Value:" + team1.get(key)+" Count:"+Collections.frequency(team1, key));// Get Key and value and count
                }

Imprimirá: Clave: United Valor: 5 Clave: Barcelona Valor: 6