Java'da HashMap'ten anahtarları alma

Java böyle bir Hashmap var:

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

Sonra şöyle dolduruyorum:

team1.put("United", 5);

Anahtarları nasıl alabilirim? Gibi bir şey: team1.getKey()"United" dönmek için.

A HashMapbirden fazla anahtar içeriyor. keySet()Tüm tuşların setini almak için kullanabilirsiniz .

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

1anahtar "foo"ve 2anahtar ile saklayacaktır "bar". Tüm tuşları yinelemek için:

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

yazdıracak "foo"ve "bar".

Eğer endeksi biliyorsanız , en azından teoride, bu yapılabilir :

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

keySet() bir küme döndürür, böylece kümesi bir diziye dönüştürürsünüz.

Sorun, elbette, bir setin siparişinizi tutmaya söz vermediğidir. HashMap'inizde yalnızca bir öğe varsa, iyisinizdir, ancak bundan daha fazlasına sahipseniz, diğer yanıtların yaptığı gibi haritanın üzerinde dolaşmak en iyisidir.

Şuna göz at.

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

( java.util.Objects.equalsHashMap içerebileceğinden kullanın null)

JDK8 + 'ı kullanma

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

Daha "genel" ve mümkün olduğunca güvenli

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

Veya JDK7 üzerindeyseniz.

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

MapYöntemi kullanarak tüm anahtarları alabilirsiniz keySet(). Şimdi, ihtiyacınız olan şey bir anahtarın değeri göz önüne alındığında , bu tamamen farklı bir konudur ve Maporada size yardımcı olmaz; BidiMapApache'nin Commons Koleksiyonlarından ( anahtar ve değerler arasında çift yönlü aramaya izin veren bir harita) gibi özel bir veri yapısına ihtiyacınız olacaktır - ayrıca birkaç farklı anahtarın aynı değere eşlenebileceğini unutmayın.

UnitedHangi değerin verildiği ( 5) bağımsız değişkenini ( ) almak istediğiniz gibi, çift ​​yönlü harita kullanmayı da düşünebilirsiniz (örneğin, Guava tarafından sağlanan: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google /common/collect/BiMap.html ).

Sadece basit bir şeye ve daha fazlasına ihtiyacınız varsa.

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

Sonra herhangi bir anahtarı arayabilirsiniz.

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

Daha hızlı yineleme için işlevsel işlemi kullanın.

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

Bir çözüm, anahtar konumunu biliyorsanız, anahtarları bir String dizisine dönüştürüp konumdaki değeri döndürmek olabilir:

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

    return keys[pos];
}

Bu basit programı deneyin:

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

HashMap'te anahtar almak için java.util.Hashmappakette bulunan keySet () yöntemimiz var . ör .:

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

Artık anahtarlar , tüm anahtarlarınızı haritada kullanabilecektir. örnek: [anahtar1, anahtar2]

Yapacağım şey çok basit ama hafıza kaybı değerleri bir anahtarla eşlemek ve anahtarları bunu yapmak için bir değerle eşlemek için oposite yapmaktır:

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

Bunu <Object, Object>haritalamak keys:Valueve Value:Keysbeğenmek için kullanmanız önemlidir

team1.put("United", 5);

team1.put(5, "United");

Yani eğer kullanırsan team1.get("United") = 5 veteam1.get(5) = "United"

Ancak çiftlerdeki nesnelerden birinde belirli bir yöntem kullanırsanız, başka bir harita yaparsanız daha iyi olacağım:

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

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

ve sonra

team1.put("United", 5);

team1Keys.put(5, "United");

ve hatırlayın, basit tutun;)

Almak için Anahtar ve değer

Örneğin

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
                }

Yazdırılacak: Anahtar: Birleşik Değer: 5 Anahtar: Barselona Değer: 6