मैं नया आइटम है कि इसी तरह के बनाना चाहते हैं जो Util.Map.Entryकि संरचना में शामिल होंगे key, value।
समस्या यह है कि मैं तुरंत नहीं कर सकता Map.Entryक्योंकि यह एक इंटरफ़ेस है।
क्या कोई जानता है कि Map.Entry के लिए एक नई सामान्य कुंजी / मान ऑब्जेक्ट कैसे बनाया जाए?
जवाबों:
आप Map.Entry<K, V>इंटरफ़ेस को स्वयं लागू कर सकते हैं :
import java.util.Map;
final class MyEntry<K, V> implements Map.Entry<K, V> {
private final K key;
private V value;
public MyEntry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V value) {
V old = this.value;
this.value = value;
return old;
}
}और फिर इसका उपयोग करें:
Map.Entry<String, Object> entry = new MyEntry<String, Object>("Hello", 123);
System.out.println(entry.getKey());
System.out.println(entry.getValue());वहाँ है public static class AbstractMap.SimpleEntry<K,V>। Abstractनाम का हिस्सा आपको गुमराह न करें: यह वास्तव में एक वर्ग नहीं हैabstract (लेकिन इसका शीर्ष-स्तर AbstractMapहै)।
तथ्य यह है कि यह एक staticनेस्टेड वर्ग है इसका मतलब है कि आपको इसे तुरंत करने के लिए एक संलग्न उदाहरण की आवश्यकता नहींAbstractMap है, इसलिए इस तरह का कुछ ठीक है:
Map.Entry<String,Integer> entry =
new AbstractMap.SimpleEntry<String, Integer>("exmpleString", 42);जैसा कि एक अन्य जवाब में कहा गया है, अमरूद में एक सुविधाजनक staticकारखाना विधि भी है Maps.immutableEntryजिसका आप उपयोग कर सकते हैं।
तुमने कहा था:
मैं
Map.Entryस्वयं का उपयोग नहीं कर सकता क्योंकि स्पष्ट रूप से यह केवल पढ़ने-योग्य वस्तु है जिसे मैं नया नहीं कर सकताinstanceof
यह पूरी तरह से सही नहीं है। इसका कारण यह है कि आप इसे सीधे नहीं कर सकते (यानी के साथ new) क्योंकि यह एक है interface Map.Entry।
जैसा कि प्रलेखन में उल्लेख किया गया AbstractMap.SimpleEntryहै @since 1.6, इसलिए यदि आप 5.0 से अटके हुए हैं, तो यह आपके लिए उपलब्ध नहीं है।
एक अन्य ज्ञात वर्ग की तलाश करने के लिए implements Map.Entry, आप वास्तव में सीधे जावाडॉक जा सकते हैं। से जावा 6 संस्करण
इंटरफ़ेस मानचित्र
सभी ज्ञात कार्यान्वयन कक्षाएं :
दुर्भाग्य से 1.5 संस्करण किसी भी ज्ञात कार्यान्वयन वर्ग को सूचीबद्ध नहीं करता है जिसका आप उपयोग कर सकते हैं, इसलिए आप अपने स्वयं के कार्यान्वयन के साथ फंस सकते हैं।
AbstractMap.SimpleEntryजावा 6 तक यह सार्वजनिक नहीं था, जैसा कि आप प्रलेखन में देख सकते हैं।
AbstractMap.SimpleEntry। मुझे लगता है तुम रोज कुछ नया सीखते हो!
जावा 9 से शुरू , एक नई उपयोगिता विधि है जो एक अपरिवर्तनीय प्रविष्टि बनाने की अनुमति देती है Map#entry(Object, Object)।
ये रहा एक सरल उदाहरण:
Entry<String, String> entry = Map.entry("foo", "bar");जैसा कि यह अपरिवर्तनीय है, कॉलिंग setValueएक फेंक देगा UnsupportedOperationException। अन्य सीमाएं इस तथ्य की हैं कि यह क्रमबद्ध नहीं है और nullजैसा कि कुंजी या मूल्य निषिद्ध है, यदि यह आपके लिए स्वीकार्य नहीं है, तो आपको उपयोग करने AbstractMap.SimpleImmutableEntryया AbstractMap.SimpleEntryइसके बजाय की आवश्यकता होगी ।
नायब: यदि आपकी आवश्यकता Map0 से 10 तक (कुंजी, मूल्य) जोड़े के साथ सीधे बनाने की है , तो आप इसके प्रकार के तरीकों का उपयोग कर सकते हैं Map.of(K key1, V value1, ...)।
अमरूद से Maps.immutableEntry का प्रयास करें
यह जावा 5 के साथ संगत होने का लाभ है (इसके विपरीत AbstractMap.SimpleEntryजावा 6 की आवश्यकता है)
AbstractMap.SimpleEntry का उदाहरण:
import java.util.Map;
import java.util.AbstractMap;
import java.util.AbstractMap.SimpleEntry;दृष्टांत:
ArrayList<Map.Entry<Integer, Integer>> arr =
new ArrayList<Map.Entry<Integer, Integer>>();पंक्तियाँ जोड़ें:
arr.add(new AbstractMap.SimpleEntry(2, 3));
arr.add(new AbstractMap.SimpleEntry(20, 30));
arr.add(new AbstractMap.SimpleEntry(2, 4));फ़ेच पंक्तियाँ:
System.out.println(arr.get(0).getKey());
System.out.println(arr.get(0).getValue());
System.out.println(arr.get(1).getKey());
System.out.println(arr.get(1).getValue());
System.out.println(arr.get(2).getKey());
System.out.println(arr.get(2).getValue());प्रिंट करना चाहिए:
2
3
20
30
2
4यह ग्राफ संरचनाओं के किनारों को परिभाषित करने के लिए अच्छा है। अपने सिर में न्यूरॉन्स के बीच की तरह।
आप वास्तव में साथ जा सकते हैं:
Map.Entry<String, String> en= Maps.immutableEntry(key, value);
org.apache.commons.lang3.tuple.Pairऔजार java.util.Map.Entryऔर स्टैंडअलोन का भी उपयोग किया जा सकता है।
जैसा कि दूसरों ने अमरूद का जिक्र किया है com.google.common.collect.Maps.immutableEntry(K, V)।
मैं Pairइसके धाराप्रवाह Pair.of(L, R)सिंटैक्स के लिए पसंद करता हूं ।
ImmutablePairइसके बजाय सुझाव दूंगा?
मैंने एक सामान्य जोड़ी वर्ग को परिभाषित किया जिसका मैं हर समय उपयोग करता हूं। यह बहुत अच्छा है। एक स्थिर कारखाने विधि (Pair.create) को परिभाषित करते हुए एक बोनस के रूप में, मुझे केवल टाइप तर्कों को अक्सर लिखना होगा।
public class Pair<A, B> {
private A component1;
private B component2;
public Pair() {
super();
}
public Pair(A component1, B component2) {
this.component1 = component1;
this.component2 = component2;
}
public A fst() {
return component1;
}
public void setComponent1(A component1) {
this.component1 = component1;
}
public B snd() {
return component2;
}
public void setComponent2(B component2) {
this.component2 = component2;
}
@Override
public String toString() {
return "<" + component1 + "," + component2 + ">";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((component1 == null) ? 0 : component1.hashCode());
result = prime * result
+ ((component2 == null) ? 0 : component2.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Pair<?, ?> other = (Pair<?, ?>) obj;
if (component1 == null) {
if (other.component1 != null)
return false;
} else if (!component1.equals(other.component1))
return false;
if (component2 == null) {
if (other.component2 != null)
return false;
} else if (!component2.equals(other.component2))
return false;
return true;
}
public static <A, B> Pair<A, B> create(A component1, B component2) {
return new Pair<A, B>(component1, component2);
}
}Pairकार्यान्वयन एक बुरी चीज है। स्रोत
यदि आप क्लोज़र का उपयोग कर रहे हैं, तो आपके पास एक और विकल्प है:
(defn map-entry
[k v]
(clojure.lang.MapEntry/create k v))