मल्टीकेपैप विधि प्राप्त करें

Question

मैं अपाचे संग्रह से मल्टीकेपैप का उपयोग करना चाहता हूं, क्योंकि मुझे दो कुंजियों और मान के साथ हैश मैप की आवश्यकता है। तत्वों में कहें मैं क्या यह:

private MultiKeyMap multiKey = new MultiKeyMap(); 
multiKey.put("key1.1", "key2.1", "value1"); 

और तत्व प्राप्त करने के लिए मैं यह कर: ऐसे ही

String s = multiKey.get("key1.1"); 

लेकिन स्ट्रिंग रों cames अशक्त ... अगर मैं दो चाबियाँ गुजरती हैं, :

String s = multiKey.get("key1.1", "key2.1"); 

स्ट्रिंग रों मूल्यों मान 1 ...

012 के साथ cames

जब मैं पास करता हूं तो दो मान में से एक में सही मूल्य प्राप्त करने के लिए मैं मल्टीकेपैप कैसे बढ़ा सकता हूं?

Answer 1

यदि आपको मूल्य प्राप्त करने के लिए केवल एक कुंजी की आवश्यकता है तो आपके पास एक सादा पुराना हैश मैप है।

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

map.put("key1.1", "value1"); 
map.put("key2.1", "value1"); 

और तत्व प्राप्त करने के लिए आप यह कर सकते हैं: जब दोनों कुंजी प्रदान किया जाना चाहिए

String s = map.get("key1.1"); // s == "value1" 

MultiKeyMap की आवश्यकता है।

Answer 2

यदि आप दो कुंजी के साथ एक मान निर्दिष्ट करते हैं, तो आपको इसे वापस पाने के लिए दोनों कुंजीों की आवश्यकता होगी। हैश फ़ंक्शन को उन सभी संभावित मानों को वापस करने के लिए डिज़ाइन नहीं किया गया है जो केवल दो कुंजियों में से एक हैं। ऐसा करने के लिए आपको एक अलग डेटा संरचना खोजने की आवश्यकता हो सकती है।

Answer 3

मल्टीकेप मैप के रूप में टुपल्स का उपयोग करने के बारे में है, एक मूल्य से अधिक एक कुंजी से मेल खाने के बारे में नहीं। एक सामान्य मानचित्र का प्रयोग करें और अलग-अलग कुंजी के साथ अपना मान दो बार रखें।

मूल्यों को हटाने के दौरान कुछ और सावधानी की आवश्यकता है। जब आप पहली कुंजी के लिए मान हटाते हैं, तो क्या आप एक ही मान के साथ स्वचालित रूप से अन्य कुंजी को हटाना चाहते हैं? यदि ऐसा है, तो आपको सभी चाबियों पर लूप करने की आवश्यकता है और हाथ से उसी मूल्य वाले लोगों को हटा दें, जो अक्षम हो सकते हैं, या किसी विशिष्ट प्रकार के रिवर्स मैप को विशिष्ट मान के लिए जल्दी से ढूंढने के लिए रखें।

Answer 4

ऐसा लगता है कि आपको मल्टीकेप की आवश्यकता नहीं है। आपको नियमित मानचित्र की आवश्यकता है। इसका उपयोग करके आप वही मान को जितनी चाहें उतनी चाबियों से जोड़ सकते हैं।

Map<String, String> map = new HashMap<String, String>(); 
Object value = ..... 
map.put("key1", value); 
map.put("key2", value); 

.................. 

if(map.get("key1") == map.get("ke2")) { 
    System.out.println("the same value stored under 2 different keys!"); 
} 

Answer 5

आप ऐसा नहीं कर सकते क्योंकि यह मल्टीकेप काम नहीं करता है। मूल्य को अलग-अलग कुंजी के साथ रखें और एक समय में प्रत्येक कुंजी के साथ इसे प्राप्त करने का प्रयास करें।

Answer 6

मुझे आपकी समस्या का सही समाधान नहीं पता है। लेकिन मेरा सुझाव है कि आप इसे पसंद लागू करने के लिए:

Map<K2, K1> m2; 
Map<K1, V> m1; 

और देखें: How to implement a Map with multiple keys?

Answer 7

इसके बजाय कि आप अमरूद से तालिका डेटा कद उपयोग कर सकते हैं की

।

Answer 8

मैं कई चाबी के लिए एक अलग वर्ग बनाने के लिए सुझाव है:

public class Test { 

Map<Shape, Book> test1 = new HashMap<>(); 
Book book = new Book("A"); 
test1.put(Shape, book); 


private class Shape { 
    String id1; 
    String id2; 
public Shape(String id1, String id2) { 
    this.id1 = id1; 
    this.id2 = id2; 
} 
@Override 
public boolean equals(Object o) {//} 
@Override 
public int hashCode() {//} 
} 

} 

Answer 9

यहाँ एक सरल MultiKeyMap कार्यान्वयन कि मेरे लिए काम किया है।

import java.util.Collection; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.Map; 
import java.util.Set; 
import java.util.UUID; 

public class MultiMap<K, V> implements Map<K, V> 
{ 
    private class MultiMapEntery implements java.util.Map.Entry<K, V> 
    { 
     private final K key; 
     private V value; 

     public MultiMapEntery(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 oldValue = this.value; 
      this.value = value; 
      return oldValue; 
     } 
    }; 

    private final Map<K, String> keyMap = new HashMap<K, String>(); 
    private final Map<String, Set<K>> inverseKeyMap = new HashMap<String, Set<K>>(); 
    private final Map<String, V> valueMap = new HashMap<String, V>(); 

    @Override 
    public void clear() 
    { 
     keyMap.clear(); 
     inverseKeyMap.clear(); 
     valueMap.clear(); 
    } 

    @Override 
    public boolean containsKey(Object key) 
    { 
     return keyMap.containsKey(key); 
    } 

    @Override 
    public boolean containsValue(Object value) 
    { 
     return valueMap.containsValue(value); 
    } 

    @Override 
    public Set<java.util.Map.Entry<K, V>> entrySet() 
    { 
     Set<java.util.Map.Entry<K, V>> entries = new HashSet<>(); 
     for(K key : keyMap.keySet()) 
     { 
      V value = valueMap.get(key); 
      entries.add(new MultiMapEntery(key, value)); 
     } 
     return entries; 
    } 

    @Override 
    public V get(Object key) 
    { 
     return valueMap.get(keyMap.get(key)); 
    } 

    @Override 
    public boolean isEmpty() 
    { 
     return valueMap.isEmpty(); 
    } 

    @Override 
    public Set<K> keySet() 
    { 
     return keyMap.keySet(); 
    } 

    @Override 
    public V put(K key, V value) 
    { 
     String id = keyMap.get(key); 
     if(id == null) 
     { 
      id = UUID.randomUUID().toString(); 
     } 
     keyMap.put(key, id); 
     Set<K> keys = inverseKeyMap.get(id); 
     if(keys == null) 
     { 
      keys = new HashSet<>(); 
     } 
     keys.add(key); 
     inverseKeyMap.put(id, keys); 
     valueMap.put(id, value); 
     return value; 
    } 

    public V put(Set<K> keys, V value) 
    { 
     String id = null; 
     for(K key : keys) 
     { 
      id = keyMap.get(key); 
      if(id != null) // one of the keys already exists 
      { 
       break; 
      } 
     } 

     if(id == null) 
     { 
      id = UUID.randomUUID().toString(); 
     } 

     for(K key : keys) 
     { 
      keyMap.put(key, id); 
     } 
     inverseKeyMap.put(id, keys); 
     valueMap.put(id, value); 
     return value; 
    } 

    @Override 
    public void putAll(Map<? extends K, ? extends V> map) 
    { 
     for(java.util.Map.Entry<? extends K, ? extends V> entry : map.entrySet()) 
     { 
      put(entry.getKey(), entry.getValue()); 
     } 
    } 

    @Override 
    public V remove(Object key) 
    { 
     String id = keyMap.get(key); 
     keyMap.remove(key); 
     Set<K> keys = inverseKeyMap.get(id); 
     keys.remove(key); 
     V value = valueMap.get(id); 
     if(keys.size() == 0) // it was the last key, now remove the value 
     { 
      valueMap.remove(id); 
     } 
     return value; 
    } 

    @Override 
    public int size() 
    { 
     return valueMap.size(); 
    } 

    @Override 
    public Collection<V> values() 
    { 
     return valueMap.values(); 
    } 

    public static void main(String[] args) 
    { 
     MultiMap<String, String> m = new MultiMap<>(); 
     m.put("a", "v1"); 
     Set<String> s = new HashSet<>(); 
     s.add("b"); 
     s.add("c"); 
     s.add("d"); 
     m.put(s, "v2"); 

     System.out.println("size:" + m.size()); 
     System.out.println("keys:" + m.keySet()); 
     System.out.println("values:" + m.values().toString()); 
     System.out.println("a:" + m.get("a")); 
     System.out.println("b:" + m.get("b")); 
     System.out.println("c:" + m.get("c")); 
     System.out.println("d:" + m.get("d")); 

     m.remove("a"); 

     System.out.println("size:" + m.size()); 
     System.out.println("keys:" + m.keySet()); 
     System.out.println("values:" + m.values().toString()); 
     System.out.println("a:" + m.get("a")); 
     System.out.println("b:" + m.get("b")); 
     System.out.println("c:" + m.get("c")); 
     System.out.println("d:" + m.get("d")); 

     s.add("a"); 
     m.put(s, "v3"); 

     System.out.println("size:" + m.size()); 
     System.out.println("keys:" + m.keySet()); 
     System.out.println("values:" + m.values().toString()); 

     System.out.println("a:" + m.get("a")); 
     System.out.println("b:" + m.get("b")); 
     System.out.println("c:" + m.get("c")); 
     System.out.println("d:" + m.get("d")); 
    } 
}