ฉันมีข้อมูลที่จัดระเบียบในรูปแบบ "คีย์ - คีย์" แทนที่จะเป็น "คีย์ - ค่า" มันเหมือน HashMap แต่ฉันจะต้องค้นหา O (1) ทั้งสองทิศทาง มีชื่อโครงสร้างข้อมูลประเภทนี้หรือไม่และสิ่งนี้รวมอยู่ในไลบรารีมาตรฐานของ Java หรือไม่ (หรืออาจจะเป็น Apache Commons?)
ฉันสามารถเขียนคลาสของตัวเองที่โดยทั่วไปใช้แผนที่มิเรอร์สองแผนที่ แต่ฉันไม่อยากสร้างวงล้อใหม่ (ถ้ามีอยู่แล้ว แต่ฉันไม่ได้ค้นหาคำที่ถูกต้อง)
คำตอบ:
นอกเหนือไปจาก Apache คอมมอนส์ฝรั่งยังมีBiMap
นี่คือคลาสง่ายๆที่ฉันใช้ในการทำสิ่งนี้ (ฉันไม่ต้องการพึ่งพาบุคคลที่สามอีก) ไม่มีคุณลักษณะทั้งหมดที่มีอยู่ใน Maps แต่เป็นการเริ่มต้นที่ดี
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;
}
แน่นอนว่าคุณต้องมีแผนที่ที่มีค่าเฉพาะ มิฉะนั้นหนึ่งในนั้นจะถูกแทนที่
แรงบันดาลใจจากคำตอบของ GETahฉันตัดสินใจเขียนสิ่งที่คล้ายกันด้วยตัวเองพร้อมการปรับปรุงบางอย่าง:
Map<K,V>-Interfaceput(อย่างน้อยฉันหวังว่าจะรับประกันได้ในที่นี้)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;
}
}
}
เป็นคำถามเก่า ๆ ที่นี่ แต่ถ้ามีคนอื่นที่สมองอุดตันเหมือนที่ฉันเพิ่งทำและสะดุดหวังว่านี่จะช่วยได้
ฉันก็กำลังมองหา HashMap แบบสองทิศทางเช่นกันบางครั้งมันก็เป็นคำตอบที่ง่ายที่สุดที่มีประโยชน์ที่สุด
หากคุณไม่ต้องการสร้างวงล้อขึ้นมาใหม่และไม่ต้องการเพิ่มไลบรารีหรือโครงการอื่น ๆ ในโครงการของคุณลองใช้อาร์เรย์แบบขนาน (หรือ 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 เนื่องจากคุณไม่ต้องสร้างใหม่หากขนาดของอาร์เรย์เปลี่ยนไปตราบใดที่คุณเพิ่ม / ลบควบคู่