Java tutorial
package edu.stanford.nlp.util; import java.io.Serializable; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * Map from keys to {@link Collection}s. Important methods are the {@link #add} * and {@link #remove} methods for adding and removing a value to/from the * Collection associated with the key, and the {@link #get} method for getting * the Collection associated with a key. The class is quite general, because on * construction, it is possible to pass a {@link MapFactory} which will be used * to create the underlying map and a {@link CollectionFactory} which will be * used to create the Collections. Thus this class can be configured to act like * a "HashSetValuedMap" or a "ListValuedMap", or even a * "HashSetValuedIdentityHashMap". The possibilities are endless! * * @param <K> Key type of map * @param <V> Type of the Collection that is the Map's value * @author Teg Grenager (grenager@cs.stanford.edu) * @author Sarah Spikes (sdspikes@cs.stanford.edu) - cleanup and filling in * types */ public class CollectionValuedMap<K, V> implements Map<K, Collection<V>>, Serializable { private static final long serialVersionUID = -9064664153962599076L; @SuppressWarnings("serial") private final Map<K, Collection<V>> map; protected final CollectionFactory<V> cf; protected final boolean treatCollectionsAsImmutable; protected final MapFactory<K, Collection<V>> mf; /** * Replaces current Collection mapped to key with the specified Collection. * Use carefully! */ @Override public Collection<V> put(K key, Collection<V> collection) { return map.put(key, collection); } /** * Unsupported. Use {@link #addAll(Map)} instead. */ @Override public void putAll(Map<? extends K, ? extends Collection<V>> m) { throw new UnsupportedOperationException(); } /** * The empty collection to be returned when a {@code get} doesn't find * the key. The collection returned should be empty, such as * Collections.emptySet, for example. */ @SuppressWarnings("serial") private final Collection<V> emptyValue; /** * @return the Collection mapped to by key, never null, but may be empty. */ @Override public Collection<V> get(Object key) { Collection<V> c = map.get(key); if (c == null) { c = emptyValue; } return c; } /** * Adds the value to the Collection mapped to by the key. */ public void add(K key, V value) { if (treatCollectionsAsImmutable) { Collection<V> newC = cf.newCollection(); Collection<V> c = map.get(key); if (c != null) { newC.addAll(c); } newC.add(value); map.put(key, newC); // replacing the old collection } else { Collection<V> c = map.get(key); if (c == null) { c = cf.newCollection(); map.put(key, c); } c.add(value); // modifying the old collection } } /** * Adds the values to the Collection mapped to by the key. */ public void addAll(K key, Collection<V> values) { if (treatCollectionsAsImmutable) { Collection<V> newC = cf.newCollection(); Collection<V> c = map.get(key); if (c != null) { newC.addAll(c); } newC.addAll(values); map.put(key, newC); // replacing the old collection } else { Collection<V> c = map.get(key); if (c == null) { c = cf.newCollection(); map.put(key, c); } c.addAll(values); // modifying the old collection } } /** Just add the key (empty collection, but key is in the keySet). */ public void addKey(K key) { Collection<V> c = map.get(key); if (c == null) { c = cf.newCollection(); map.put(key, c); } } /** * Adds all of the mappings in m to this CollectionValuedMap. If m is a * CollectionValuedMap, it will behave strangely. Use the constructor instead. */ public void addAll(Map<K, V> m) { if (m instanceof CollectionValuedMap<?, ?>) { throw new UnsupportedOperationException(); } for (Map.Entry<K, V> e : m.entrySet()) { add(e.getKey(), e.getValue()); } } public void addAll(CollectionValuedMap<K, V> cvm) { for (Entry<K, Collection<V>> entry : cvm.entrySet()) { K key = entry.getKey(); Collection<V> currentCollection = get(key); Collection<V> newValues = entry.getValue(); if (treatCollectionsAsImmutable) { Collection<V> newCollection = cf.newCollection(); if (currentCollection != null) { newCollection.addAll(currentCollection); } newCollection.addAll(newValues); map.put(key, newCollection); // replacing the old collection } else { boolean needToAdd = false; if (currentCollection == emptyValue) { currentCollection = cf.newCollection(); needToAdd = true; } currentCollection.addAll(newValues); // modifying the old collection if (needToAdd) { map.put(key, currentCollection); } } } } /** * Removes the mapping associated with this key from this Map. * * @return the Collection mapped to by this key. */ @Override public Collection<V> remove(Object key) { return map.remove(key); } /** * Removes the mappings associated with the keys from this map. * * @param keys They keys to remove */ @SuppressWarnings("Convert2streamapi") public void removeAll(Collection<K> keys) { for (K k : keys) { remove(k); } } /** * Removes the value from the Collection mapped to by this key, leaving the * rest of the collection intact. * * @param key The key to the Collection to remove the value from * @param value The value to remove */ public void removeMapping(K key, V value) { if (treatCollectionsAsImmutable) { Collection<V> c = map.get(key); if (c != null) { Collection<V> newC = cf.newCollection(); newC.addAll(c); newC.remove(value); map.put(key, newC); } } else { Collection<V> c = get(key); c.remove(value); } } /** * Clears this Map. */ @Override public void clear() { map.clear(); } /** * @return true iff this key is in this map */ @Override public boolean containsKey(Object key) { return map.containsKey(key); } /** * Unsupported. */ @Override public boolean containsValue(Object value) { throw new UnsupportedOperationException(); } /** * @return true iff this Map has no mappings in it. */ @Override public boolean isEmpty() { return map.isEmpty(); } /** * Each element of the Set is a Map.Entry object, where getKey() returns the * key of the mapping, and getValue() returns the Collection mapped to by the * key. * * @return a Set view of the mappings contained in this map. */ @Override public Set<Entry<K, Collection<V>>> entrySet() { return map.entrySet(); } /** * @return a Set view of the keys in this Map. */ @Override public Set<K> keySet() { return map.keySet(); } /** * The number of keys in this map. */ @Override public int size() { return map.size(); } /** * @return a collection of the values (really, a collection of values) in this * Map */ @Override public Collection<Collection<V>> values() { return map.values(); } @SuppressWarnings("Convert2streamapi") public Collection<V> allValues() { Collection<V> c = cf.newCollection(); for (Collection<V> c1 : map.values()) { c.addAll(c1); } return c; } /** * @return true iff o is a CollectionValuedMap, and each key maps to the a * Collection of the same objects in o as it does in this * CollectionValuedMap. */ @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof CollectionValuedMap<?, ?>)) { return false; } CollectionValuedMap<K, V> other = ErasureUtils.uncheckedCast(o); if (other.size() != size()) { return false; } try { for (Map.Entry<K, Collection<V>> e : entrySet()) { K key = e.getKey(); Collection<V> value = e.getValue(); if (value == null) { if (!(other.get(key) == null && other.containsKey(key))) { return false; } } else { if (!value.equals(other.get(key))) { return false; } } } } catch (ClassCastException | NullPointerException unused) { return false; } return true; } /** * @return the hashcode of the underlying Map */ @Override public int hashCode() { return map.hashCode(); } /** * Creates a "delta copy" of this Map, where only the differences * from the original Map are represented. (This typically assumes * that this map will no longer be changed.) */ public CollectionValuedMap<K, V> deltaCopy() { Map<K, Collection<V>> deltaMap = new DeltaMap<>(this.map); return new CollectionValuedMap<>(null, cf, true, deltaMap); } /** * @return A String representation of this CollectionValuedMap, with special * machinery to avoid recursion problems */ @Override public String toString() { StringBuilder buf = new StringBuilder(); buf.append('{'); Iterator<Entry<K, Collection<V>>> i = entrySet().iterator(); while (i.hasNext()) { Map.Entry<K, Collection<V>> e = i.next(); K key = e.getKey(); Collection<V> value = e.getValue(); buf.append(key == this ? "(this Map)" : key).append('=').append(value == this ? "(this Map)" : value); if (i.hasNext()) { buf.append(", "); } } buf.append('}'); return buf.toString(); } /** * Creates a new empty CollectionValuedMap. * * @param mf A MapFactory which will be used to generate the underlying Map * @param cf A CollectionFactory which will be used to generate the Collections * in each mapping * @param treatCollectionsAsImmutable If true, forces this Map to create new a Collection every time a * new value is added to or deleted from the Collection a mapping. */ public CollectionValuedMap(MapFactory<K, Collection<V>> mf, CollectionFactory<V> cf, boolean treatCollectionsAsImmutable) { this(mf, cf, treatCollectionsAsImmutable, null); } /** * Creates a new CollectionValuedMap. * * @param mf A MapFactory which will be used to generate the underlying Map * @param cf A CollectionFactory which will be used to generate the Collections * in each mapping * @param treatCollectionsAsImmutable If true, forces this Map to create new a Collection every time a * new value is added to or deleted from the Collection a mapping. * @param map An existing map to use rather than initializing one with mf. If this is non-null it is * used to initialize the map rather than mf. */ private CollectionValuedMap(MapFactory<K, Collection<V>> mf, CollectionFactory<V> cf, boolean treatCollectionsAsImmutable, Map<K, Collection<V>> map) { if (cf == null) { throw new IllegalArgumentException(); } if (mf == null && map == null) { throw new IllegalArgumentException(); } this.mf = mf; this.cf = cf; this.treatCollectionsAsImmutable = treatCollectionsAsImmutable; this.emptyValue = cf.newEmptyCollection(); if (map != null) { this.map = map; } else { this.map = Collections.synchronizedMap(mf.newMap()); } } /** * Creates a new CollectionValuedMap with all of the mappings from cvm. * * @param cvm The CollectionValueMap to copy as this object. */ public CollectionValuedMap(CollectionValuedMap<K, V> cvm) { this.mf = cvm.mf; this.cf = cvm.cf; this.treatCollectionsAsImmutable = cvm.treatCollectionsAsImmutable; this.emptyValue = cvm.emptyValue; map = Collections.synchronizedMap(mf.newMap()); for (Map.Entry<K, Collection<V>> entry : cvm.map.entrySet()) { K key = entry.getKey(); Collection<V> c = entry.getValue(); for (V value : c) { add(key, value); } } } /** * Creates a new empty CollectionValuedMap which uses a HashMap as the * underlying Map, and HashSets as the Collections in each mapping. Does not * treat Collections as immutable. */ public CollectionValuedMap() { this(MapFactory.hashMapFactory(), CollectionFactory.hashSetFactory(), false); } /** * Creates a new empty CollectionValuedMap which uses a HashMap as the * underlying Map. Does not treat Collections as immutable. * * @param cf A CollectionFactory which will be used to generate the Collections * in each mapping */ public CollectionValuedMap(CollectionFactory<V> cf) { this(MapFactory.hashMapFactory(), cf, false); } }