Dispongo di dati organizzati in una sorta di formato "chiave-chiave", piuttosto che "valore-chiave". È come una HashMap, ma avrò bisogno di una ricerca O (1) in entrambe le direzioni. Esiste un nome per questo tipo di struttura dati e qualcosa di simile è incluso nelle librerie standard di Java? (o forse Apache Commons?)
Potrei scrivere la mia classe che fondamentalmente utilizza due mappe speculari, ma preferirei non reinventare la ruota (se esiste già ma non sto cercando il termine giusto).
Risposte:
Non esiste una classe di questo tipo nell'API Java. La classe Apache Commons che desideri sarà una delle implementazioni di BidiMap .
Come matematico, definirei questo tipo di struttura una biiezione.
Ecco una semplice classe che ho usato per ottenere questo risultato (non volevo avere ancora un'altra dipendenza da terze parti). Non offre tutte le funzionalità disponibili in Maps ma è un buon inizio.
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);
}
}Se non si verificano collisioni, puoi sempre aggiungere entrambe le direzioni alla stessa HashMap :-)
Ecco i miei 2 centesimi.
Oppure puoi usare un metodo semplice con i generici. Pezzo di torta.
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;
}Ovviamente devi avere una mappa con valori univoci. In caso contrario, uno di essi verrà sostituito.
Ispirato dalla risposta di GETah ho deciso di scrivere qualcosa di simile da solo con alcuni miglioramenti:
Map<K,V>-Interfaceput(almeno spero di garantirlo qui)L'utilizzo è proprio come una normale mappa, per ottenere una vista inversa sulla chiamata di mappatura getReverseView(). Il contenuto non viene copiato, viene restituita solo una visualizzazione.
Non sono sicuro che sia totalmente infallibile (in realtà, probabilmente non lo è), quindi sentiti libero di commentare se noti qualche difetto e aggiornerò la risposta.
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;
}
}
}Una domanda piuttosto vecchia qui, ma se qualcun altro ha un blocco cerebrale come ho appena fatto e si imbatte in questo, si spera che questo possa aiutare.
Anch'io stavo cercando una HashMap bidirezionale, a volte è la più semplice delle risposte quella più utile.
Se non desideri reinventare la ruota e preferisci non aggiungere altre librerie o progetti al tuo progetto, che ne dici di una semplice implementazione di array paralleli (o ArrayList se il tuo progetto lo richiede).
SomeType[] keys1 = new SomeType[NUM_PAIRS];
OtherType[] keys2 = new OtherType[NUM_PAIRS];Non appena conosci l'indice di 1 delle due chiavi puoi facilmente richiedere l'altra. Quindi i tuoi metodi di ricerca potrebbero assomigliare a:
SomeType getKey1(OtherType ot);
SomeType getKey1ByIndex(int key2Idx);
OtherType getKey2(SomeType st);
OtherType getKey2ByIndex(int key2Idx);Questo presuppone che tu stia utilizzando strutture orientate agli oggetti appropriate, dove solo i metodi stanno modificando questi array / ArrayList, sarebbe molto semplice mantenerli paralleli. Ancora più facile per un ArrayList poiché non dovresti ricostruire se la dimensione degli array cambia, a patto che tu aggiunga / rimuovi in tandem.