আমার কাছে এমন ডেটা রয়েছে যা "কী-মান" পরিবর্তে "কী-কী" ফর্ম্যাটের মতো সংগঠিত। এটি হ্যাশম্যাপের মতো, তবে উভয় দিক দিয়ে আমার ও (1) অনুসন্ধান প্রয়োজন। এই জাতীয় ডাটা স্ট্রাকচারের জন্য কি কোনও নাম রয়েছে এবং জাভা-র স্ট্যান্ডার্ড লাইব্রেরিতে এর মতো কিছু রয়েছে? (বা হতে পারে অ্যাপাচি কমন্স?)
আমি আমার নিজের ক্লাসটি লিখতে পারি যা মূলত দুটি মিররযুক্ত মানচিত্র ব্যবহার করে তবে আমি চাকাটি পুনরায় উদ্ভাবন করব না (যদি এটি ইতিমধ্যে বিদ্যমান তবে আমি কেবল সঠিক শব্দটির সন্ধান করছি না)।
উত্তর:
জাভা এপিআইতে এ জাতীয় কোনও শ্রেণি নেই। আপনি যে অ্যাপাচি কমন্স ক্লাসটি চান তা বিড়িম্যাপের অন্যতম বাস্তবায়ন হতে চলেছে ।
একজন গণিতবিদ হিসাবে আমি এই ধরণের কাঠামোটিকে বাইজেকশন বলব।
এটি সম্পন্ন করতে এখানে আমি ব্যবহার করি এমন একটি সাধারণ ক্লাস (আমি আর একটি তৃতীয় পক্ষের নির্ভরতা পেতে চাইনি)। এটি মানচিত্রে উপলব্ধ সমস্ত বৈশিষ্ট্য সরবরাহ করে না তবে এটি একটি ভাল শুরু start
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);
}
}
যদি কোনও সংঘর্ষ না ঘটে, আপনি সর্বদা একই হ্যাশম্যাপে উভয় দিক যুক্ত করতে পারেন :-)
এখানে আমার 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;
}
}
}
এখানে বেশ পুরানো প্রশ্ন, তবে অন্য কারও যদি মস্তিষ্কের অবরুদ্ধ থাকে যেমন আমি ঠিক করেছি এবং এতে হোঁচট খেয়েছি, আশা করি এটি সাহায্য করবে।
আমিও দ্বি-দিকনির্দেশক হ্যাশম্যাপের সন্ধান করছিলাম, কখনও কখনও এটি উত্তরগুলির সর্বাধিক দরকারী যা সর্বাধিক দরকারী।
আপনি যদি চাকাটি পুনরায় উদ্ভাবন করতে না চান এবং আপনার প্রকল্পে অন্যান্য গ্রন্থাগার বা প্রকল্পগুলি যুক্ত না করতে পছন্দ করেন, তবে কীভাবে সমান্তরাল অ্যারেগুলির একটি সাধারণ বাস্তবায়ন (বা আপনার নকশার দাবি থাকলে অ্যারেলিস্টস) how
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);
এটি ধরে নেওয়া হচ্ছে আপনি সঠিক অবজেক্ট ভিত্তিক কাঠামো ব্যবহার করছেন, যেখানে কেবল পদ্ধতিগুলি এই অ্যারে / অ্যারেলিস্টগুলিকে সংশোধন করছে, তাদের সমান্তরাল রাখা খুব সহজ হবে। অ্যারেলিস্টের পক্ষে আরও সহজ যেহেতু আপনাকে আর তৈরি করতে হবে না যদি অ্যারের আকার পরিবর্তন হয়, আপনি যতক্ষণ না যোগ / সরিয়ে ফেলেন ততক্ষণ।