मेरे पास डेटा है जो "की-वैल्यू" के बजाय "की-की" फॉर्मेट के प्रकार में व्यवस्थित है। यह एक HashMap की तरह है, लेकिन मुझे दोनों दिशाओं में O (1) लुकअप की आवश्यकता होगी। क्या इस प्रकार की डेटा संरचना के लिए एक नाम है, और क्या जावा की मानक पुस्तकालयों में ऐसा कुछ भी शामिल है? (या शायद अपाचे कॉमन्स?)
मैं अपनी खुद की क्लास लिख सकता था जो मूल रूप से दो मिरर किए गए मैप्स का उपयोग करता है, लेकिन मैं पहिया को सुदृढ़ नहीं करूंगा (यदि यह पहले से मौजूद है लेकिन मैं सिर्फ सही अवधि के लिए नहीं खोज रहा हूं)।
जवाबों:
जावा एपीआई में ऐसा कोई वर्ग नहीं है। अपाचे कॉमन्स वर्ग जो आप चाहते हैं, वह बिडिएप के कार्यान्वयन में से एक होने जा रहा है ।
एक गणितज्ञ के रूप में, मैं इस तरह की संरचना को एक आपत्ति कहूंगा।
यहाँ एक सरल वर्ग है जिसका उपयोग मैं यह करने के लिए करता था (मैं अभी तक एक और तृतीय पक्ष निर्भरता नहीं चाहता था)। यह मैप्स में उपलब्ध सभी सुविधाओं की पेशकश नहीं करता है लेकिन यह एक अच्छी शुरुआत है।
public class BidirectionalMap<KeyType, ValueType>{
private Map<KeyType, ValueType> keyToValueMap = new ConcurrentHashMap<KeyType, ValueType>();
private Map<ValueType, KeyType> valueToKeyMap = new ConcurrentHashMap<ValueType, KeyType>();
synchronized public void put(KeyType key, ValueType value){
keyToValueMap.put(key, value);
valueToKeyMap.put(value, key);
}
synchronized public ValueType removeByKey(KeyType key){
ValueType removedValue = keyToValueMap.remove(key);
valueToKeyMap.remove(removedValue);
return removedValue;
}
synchronized public KeyType removeByValue(ValueType value){
KeyType removedKey = valueToKeyMap.remove(value);
keyToValueMap.remove(removedKey);
return removedKey;
}
public boolean containsKey(KeyType key){
return keyToValueMap.containsKey(key);
}
public boolean containsValue(ValueType value){
return keyToValueMap.containsValue(value);
}
public KeyType getKey(ValueType value){
return valueToKeyMap.get(value);
}
public ValueType get(KeyType key){
return keyToValueMap.get(key);
}
}यदि कोई टक्कर नहीं होती है, तो आप हमेशा दोनों दिशाओं को एक ही HashMap :-) में जोड़ सकते हैं
यहाँ मेरे 2 सेंट।
या आप जेनरिक के साथ एक सरल विधि का उपयोग कर सकते हैं। केक का टुकड़ा।
public static <K,V> Map<V, K> invertMap(Map<K, V> toInvert) {
Map<V, K> result = new HashMap<V, K>();
for(K k: toInvert.keySet()){
result.put(toInvert.get(k), k);
}
return result;
}बेशक आप अद्वितीय मूल्यों के साथ एक नक्शा होना चाहिए। अन्यथा, उनमें से एक को बदल दिया जाएगा।
गीता के उत्तर से प्रेरित होकर मैंने कुछ सुधारों के साथ खुद भी ऐसा ही कुछ लिखने का फैसला किया:
Map<K,V>-इंटरफेसput(इसकी कम से कम मैं इसे गारंटी देने की उम्मीद करता हूं) इसकी देखभाल करके वास्तव में इसकी गारंटी दी जाती हैमानचित्रण कॉल पर रिवर्स दृश्य प्राप्त करने के लिए उपयोग सामान्य मानचित्र की तरह है getReverseView()। सामग्री की प्रतिलिपि नहीं बनाई गई है, केवल एक दृश्य लौटाया गया है।
मुझे यकीन नहीं है कि यह पूरी तरह से मूर्खतापूर्ण है (वास्तव में, यह शायद नहीं है), इसलिए टिप्पणी करने के लिए स्वतंत्र महसूस करें यदि आपको कोई दोष दिखाई देता है और मैं उत्तर को अपडेट करूंगा।
public class BidirectionalMap<Key, Value> implements Map<Key, Value> {
private final Map<Key, Value> map;
private final Map<Value, Key> revMap;
public BidirectionalMap() {
this(16, 0.75f);
}
public BidirectionalMap(int initialCapacity) {
this(initialCapacity, 0.75f);
}
public BidirectionalMap(int initialCapacity, float loadFactor) {
this.map = new HashMap<>(initialCapacity, loadFactor);
this.revMap = new HashMap<>(initialCapacity, loadFactor);
}
private BidirectionalMap(Map<Key, Value> map, Map<Value, Key> reverseMap) {
this.map = map;
this.revMap = reverseMap;
}
@Override
public void clear() {
map.clear();
revMap.clear();
}
@Override
public boolean containsKey(Object key) {
return map.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return revMap.containsKey(value);
}
@Override
public Set<java.util.Map.Entry<Key, Value>> entrySet() {
return Collections.unmodifiableSet(map.entrySet());
}
@Override
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public Set<Key> keySet() {
return Collections.unmodifiableSet(map.keySet());
}
@Override
public void putAll(Map<? extends Key, ? extends Value> m) {
m.entrySet().forEach(e -> put(e.getKey(), e.getValue()));
}
@Override
public int size() {
return map.size();
}
@Override
public Collection<Value> values() {
return Collections.unmodifiableCollection(map.values());
}
@Override
public Value get(Object key) {
return map.get(key);
}
@Override
public Value put(Key key, Value value) {
Value v = remove(key);
getReverseView().remove(value);
map.put(key, value);
revMap.put(value, key);
return v;
}
public Map<Value, Key> getReverseView() {
return new BidirectionalMap<>(revMap, map);
}
@Override
public Value remove(Object key) {
if (containsKey(key)) {
Value v = map.remove(key);
revMap.remove(v);
return v;
} else {
return null;
}
}
}यहाँ एक पुराना सवाल है, लेकिन अगर किसी और के मस्तिष्क ब्लॉक है जैसे मैंने अभी किया और इस पर ठोकर खाई, उम्मीद है कि इससे मदद मिलेगी।
मैं भी एक द्वि-दिशात्मक हैशपॉप की तलाश में था, कभी-कभी यह उन उत्तरों में सबसे सरल होता है जो सबसे उपयोगी होते हैं।
यदि आप पहिया का फिर से आविष्कार नहीं करना चाहते हैं और अपनी परियोजना में अन्य पुस्तकालयों या परियोजनाओं को जोड़ना पसंद नहीं करते हैं, तो समानांतर सरणियों के एक साधारण कार्यान्वयन के बारे में कैसे (या यदि आपका डिज़ाइन इसकी मांग करता है तो ArrayLists)।
SomeType[] keys1 = new SomeType[NUM_PAIRS];
OtherType[] keys2 = new OtherType[NUM_PAIRS];जैसे ही आपको दो चाबियों में से 1 का इंडेक्स पता चलता है आप आसानी से दूसरे से अनुरोध कर सकते हैं। तो आपके देखने के तरीके कुछ इस तरह दिख सकते हैं:
SomeType getKey1(OtherType ot);
SomeType getKey1ByIndex(int key2Idx);
OtherType getKey2(SomeType st);
OtherType getKey2ByIndex(int key2Idx);यह मान रहा है कि आप उचित ऑब्जेक्ट ओरिएंटेड स्ट्रक्चर्स का उपयोग कर रहे हैं, जहाँ केवल तरीके इन सरणियों / ArrayLists को संशोधित कर रहे हैं, उन्हें समानांतर रखना बहुत सरल होगा। एक ArrayList के लिए और भी आसान है क्योंकि आपको सरणियों का आकार बदलने पर पुनर्निर्माण नहीं करना होगा, इसलिए जब तक आप अग्रानुक्रम में जोड़ते / हटाते हैं।