"Anahtar-değer" yerine "anahtar-anahtar" biçiminde düzenlenmiş verilerim var. Bu bir HashMap gibi, ancak her iki yönde de O (1) aramasına ihtiyacım olacak. Bu tür bir veri yapısı için bir isim var mı ve buna benzer herhangi bir şey Java'nın standart kitaplıklarına dahil mi? (veya belki Apache Commons?)
Temelde iki yansıtılmış Harita kullanan kendi sınıfımı yazabilirim, ancak tekerleği yeniden icat etmemeyi tercih ederim (eğer bu zaten mevcutsa ama sadece doğru terimi aramıyorum).
Yanıtlar:
Java API'de böyle bir sınıf yoktur. İstediğiniz Apache Commons sınıfı, BidiMap'in uygulamalarından biri olacak .
Bir matematikçi olarak, bu tür bir yapıya bir eşleştirme derdim.
İşte bunu yapmak için kullandığım basit bir sınıf (henüz başka bir üçüncü taraf bağımlılığına sahip olmak istemedim). Haritalar'da bulunan tüm özellikleri sunmaz, ancak iyi bir başlangıçtır.
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);
}
}Çarpışma meydana gelmezse, her zaman aynı HashMap'e her iki yönü de ekleyebilirsiniz :-)
İşte benim 2 sentim.
Veya jeneriklerle basit bir yöntem kullanabilirsiniz. Kekin parçası.
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;
}Elbette benzersiz değerlere sahip bir haritanız olmalıdır. Aksi takdirde biri değiştirilecektir.
GETah'ın cevabından esinlenerek , bazı iyileştirmelerle kendi başıma benzer bir şey yazmaya karar verdim:
Map<K,V>-Interface'i uyguluyorput(en azından burada garanti etmeyi umuyorum)Haritalama çağrısında ters bir görünüm elde etmek için kullanım normal bir harita gibidir getReverseView(). İçerik kopyalanmaz, sadece bir görünüm döndürülür.
Bunun tamamen aptalca bir kanıt olduğundan emin değilim (aslında, muhtemelen değil), bu yüzden herhangi bir kusur fark ederseniz yorum yapmaktan çekinmeyin ve cevabı güncelleyeceğim.
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;
}
}
}Burada oldukça eski bir soru, ama benim yaptığım gibi başka biri beyin bloğuna sahipse ve bu konuda tökezlerse, umarım bu yardımcı olur.
Ben de iki yönlü bir HashMap arıyordum, bazen en kullanışlı olan en basit cevaplardır.
Tekerleği yeniden icat etmek istemiyor ve projenize başka kitaplıklar veya projeler eklememeyi tercih ediyorsanız, paralel dizilerin (veya tasarımınız gerektiriyorsa Dizi Listelerinin) basit bir şekilde uygulanmasına ne dersiniz?
SomeType[] keys1 = new SomeType[NUM_PAIRS];
OtherType[] keys2 = new OtherType[NUM_PAIRS];İki anahtardan birinin indeksini öğrenir öğrenmez diğerini kolayca talep edebilirsiniz. Böylece arama yöntemleriniz şuna benzer olabilir:
SomeType getKey1(OtherType ot);
SomeType getKey1ByIndex(int key2Idx);
OtherType getKey2(SomeType st);
OtherType getKey2ByIndex(int key2Idx);Bu, uygun nesne yönelimli yapılar kullandığınızı varsayar, burada sadece yöntemler bu dizileri / Dizi Listelerini değiştirir, onları paralel tutmak çok basit olacaktır. Art arda ekleyip çıkardığınız sürece, dizilerin boyutu değişirse yeniden oluşturmak zorunda kalmayacağınızdan, bir ArrayList için daha da kolaydır.