Re: How associate two HashMaps
javax.swing.JSnarker wrote:
Stefan Ram wrote:
Ricardo Nuno writes:
What do I need to associate a value, from one hashMap to a key from a
new HashMap
It is hard to parse this sentence with the comma.
=BBTo associate a value to a key=AB is a little bit vague.
My guess is that he wants a bidirectional map. For that you'd need a
custom class delegating to two internal HashMap instances. Something like
public class BidiMap<K,V> extends AbstractMap<K,V> {
In Apache Commons Collections 'BidiMap' is an interface with a double handf=
ul
of implementing classes:
<http://commons.apache.org/collections/api-release/org/apache/commons/colle=
ctions/BidiMap.html>
private Map<K,V> map1, map2;
private BidiMap<V,K> reversed;
public BidiMap () {
map1 = new HashMap<K,V>();
map2 = new HashMap<K,V>();
reversed = new BidiMap<K,V>(map2, map1, this);
}
private BidiMap (Map<K,V> map1, Map<K,V> map2, BidiMap<V,K> reversed=
) {
this.map1 = map1; this.map2 = map2; this.reversed = revers=
ed;
}
private BidiMap<V,K> getReversedMap () {
return reversed;
}
/* Map methods go here. View methods delegate to map1. Modifying
methods operate on both maps, but reverse key and value when
modifying map2. Also, if a value is already in map2, looks
it up in map2 to find the corresponding key and removes
that key from map1 before adding the new mappings to both maps.
*/
}
Changes to the reversed map will be reflected in the original and vice
versa.
JSnarker's example is a good one for understanding the mechanics of the
bidirectional map. The Apache Commons libraries are the go-to source for
most convenience types not in the standard API.
If you need a different kind of association, well, there are all kinds of w=
ays
to do that, as Stefan pointed out.
Another possibility is that you're looking for a way to associate more than=
one value with the same key. There are a number of ways to do that:
Here's one (not tried or even compiled here, so might need tweaking):
public interface Pair<L, R>
{
L getLeft();
R getRight();
}
public class BasePair<L, R> implements Pair<L, R>
{
private final L left;
private final R right;
public BasePair(L left, R right)
{
this.left = left;
this.right = right;
}
public L getLeft() { return left; }
public R getRight() { return right; }
}
public class MultiAssociator<K, L, R>
{
private final Map<K, Pair<L, R>> associator = new HashMap<>();
public Pair<L, R> put(K key, Pair<L, R> pair)
{
if (key == null || pair == null)
{
throw new IllegalArgumentException("Argument cannot be null");
}
return associator.put(key, pair);
}
public Pair<L, R> put(K key, L left, R right)
{
return associator.put(key, new Pair<>(left, right));
}
public Pair<L, R> put(K key, L left)
{
if (key == null)
{
throw new IllegalArgumentException("Argument cannot be null");
}
Pair<L, R> value = associator.get(key);
Pair<L, R> repla = value == null? new Pair<>(left, null)
: new Pair<>(left, value.getRight());
return associator.put(key, repla);
}
public Pair<L, R> put(K key, R right)
{
if (key == null)
{
throw new IllegalArgumentException("Argument cannot be null");
}
Pair<L, R> value = associator.get(key);
Pair<L, R> repla = value == null? new Pair(null, right)
: new Pair(value.getLeft(), right);
return associator.put(key, repla);
}
public Pair<L, R> get(K key)
{
return associator.get(key);
}
}
--
Lew