मेरे पास इस तरह जावा में एक हैशमैप है:
private Map<String, Integer> team1 = new HashMap<String, Integer>();फिर मैं इसे इस तरह भरता हूं:
team1.put("United", 5);मुझे चाबी कैसे मिल सकती है? कुछ इस तरह: team1.getKey()"यूनाइटेड" वापस करने के लिए।
intइस तरह एकल लोगों के लिए इस्तेमाल किया जाना चाहिए।
जवाबों:
A HashMapमें एक से अधिक कुंजी हैं। आप keySet()सभी कुंजी का सेट प्राप्त करने के लिए उपयोग कर सकते हैं ।
team1.put("foo", 1);
team1.put("bar", 2);1कुंजी के साथ "foo"और कुंजी के साथ स्टोर करेगा । सभी कुंजियों पर पुनरावृति करने के लिए:2"bar"
for ( String key : team1.keySet() ) {
System.out.println( key );
}प्रिंट होगा "foo"और "bar"।
List<String> keys = new ArrayList<>(mLoginMap.keySet());
यह उल्लेखनीय है, कम से कम सिद्धांत में, यदि आप सूचकांक जानते हैं:
System.out.println(team1.keySet().toArray()[0]);keySet() एक सेट लौटाता है, इसलिए आप सेट को एक सरणी में बदलते हैं।
बेशक, समस्या यह है कि एक सेट आपके आदेश को रखने का वादा नहीं करता है। यदि आपके पास आपके हाशपैप में केवल एक आइटम है, तो आप अच्छे हैं, लेकिन यदि आपके पास इससे अधिक है, तो नक्शे पर लूप करना सबसे अच्छा है, जैसा कि अन्य उत्तरों ने किया है।
HashMap। अच्छा प्रदर्शन।
इसे देखो।
https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html
(उपयोग करें java.util.Objects.equalsक्योंकि HashMap शामिल हो सकते हैं null)
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());
}अधिक "सामान्य" और जितना संभव हो उतना सुरक्षित
/**
* 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());
}या अगर आप 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;
}HashMapकुंजी अद्वितीय हैं।
आप Mapविधि का उपयोग करके सभी कुंजियों को पुनः प्राप्त कर सकते हैं keySet()। अब, एक करने के लिए करता है, तो क्या आप की जरूरत है कुंजी अपने दिए गए मूल्य , एक बिल्कुल अलग बात है और कहा कि Mapतुम वहाँ में मदद नहीं करेगा; BidiMapअपाचे के कॉमन्स कलेक्शंस से आपको एक विशेष डेटा संरचना की आवश्यकता होती है, जैसे (एक नक्शा जो कुंजी और मूल्यों के बीच द्विदिश लुकअप की अनुमति देता है) - यह भी ध्यान रखें कि कई अलग-अलग कुंजियों को समान मूल्य पर मैप किया जा सकता है।
जैसा कि आप तर्क प्राप्त करना चाहते हैं ( United) जिसके लिए मूल्य दिया गया है ( 5) आप द्विदिश मानचित्र का उपयोग करने पर भी विचार कर सकते हैं (उदाहरण के लिए अमरूद: http://docs.guava-lbooks.googlecode.com/git/javadoc/com/google /common/collect/BiMap.html )।
यदि आपको बस कुछ सरल और अधिक सत्यापन की आवश्यकता है।
public String getKey(String key)
{
if(map.containsKey(key)
{
return key;
}
return null;
}फिर आप किसी भी कुंजी को खोज सकते हैं।
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());
}next()दो बार लूप में कॉल करने का मतलब है कि आप सम-संख्या वाले मानों के साथ विषम संख्या वाली कुंजियों को प्रिंट करेंगे।
एक समाधान हो सकता है, यदि आप प्रमुख स्थिति जानते हैं, तो कुंजियों को स्ट्रिंग सरणी में बदल दें और स्थिति में मान लौटाएँ:
public String getKey(int pos, Map map) {
String[] keys = (String[]) map.keySet().toArray(new String[0]);
return keys[pos];
}इस सरल कार्यक्रम का प्रयास करें:
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);
}
}
}हाशप में कुंजी प्राप्त करने के लिए, हमारे पास कीसेट () विधि है जो java.util.Hashmapपैकेज में मौजूद है । पूर्व:
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();अब चाबियाँ आपके सभी कुंजी के नक्शे में उपलब्ध होंगी। पूर्व: [की १, की २]
java,util.HashMapएक वर्ग है, पैकेज नहीं है, और यहां ऐसा कुछ भी नहीं है जो पांच साल पहले यहां नहीं था।
मैं जो करूँगा वह बहुत ही सरल है लेकिन बेकार की यादों को एक कुंजी के साथ मानों को मैप करना है और इस मान के साथ कुंजियों को मैप करने के लिए oposite करना है:
private Map<Object, Object> team1 = new HashMap<Object, Object>();
यह महत्वपूर्ण है कि आप इसका उपयोग करें <Object, Object>ताकि आप इसे मैप कर सकें keys:Valueऔर इसे Value:Keysपसंद कर सकें
team1.put("United", 5);
team1.put(5, "United");
इसलिए यदि आप उपयोग करते हैं team1.get("United") = 5औरteam1.get(5) = "United"
लेकिन अगर आप जोड़े में मौजूद वस्तुओं में से किसी एक पर कुछ विशिष्ट विधि का उपयोग करते हैं तो मैं बेहतर होगा यदि आप एक और नक्शा बनाते हैं:
private Map<String, Integer> team1 = new HashMap<String, Integer>();
private Map<Integer, String> team1Keys = new HashMap<Integer, String>();
और फिर
team1.put("United", 5);
team1Keys.put(5, "United");
और याद रखें, इसे सरल रखें;)
कुंजी और इसके मूल्य प्राप्त करने के लिए
जैसे
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
}विल प्रिंट: की: युनाइटेड वैल्यू: 5 की: बार्सिलोना वैल्यू: ६
team1.getKey()यदि आप वापसी की उम्मीद करते हैं तो: (1) नक्शा खाली है, या (2) यदि इसमें कई कुंजियाँ हैं?