package resourceCode.map; import java.util.Collection; import java.util.Map; import java.util.Set; public interface MyMap { // Query Operations /** * Returns the number of key-value mappings in this map. If the map contains * more than Integer.MAX_VALUE elements, returns * Integer.MAX_VALUE. * * @return the number of key-value mappings in this map */ int size(); /** * Returns true if this map contains no key-value mappings. * * @return true if this map contains no key-value mappings */ boolean isEmpty(); /** * Returns true if this map contains a mapping for the specified key. * More formally, returns true if and only if this map contains a * mapping for a key k such that * (key==null ? k==null : key.equals(k)). (There can be at most one * such mapping.) * * @param key * key whose presence in this map is to be tested * @return true if this map contains a mapping for the specified key * @throws ClassCastException * if the key is of an inappropriate type for this map (optional) * @throws NullPointerException * if the specified key is null and this map does not permit null * keys (optional) */ boolean containsKey(Object key); /** * Returns true if this map maps one or more keys to the specified * value. More formally, returns true if and only if this map contains * at least one mapping to a value v such that * (value==null ? v==null : value.equals(v)). This operation will * probably require time linear in the map size for most implementations of the * Map interface. * * @param value * value whose presence in this map is to be tested * @return true if this map maps one or more keys to the specified * value * @throws ClassCastException * if the value is of an inappropriate type for this map (optional) * @throws NullPointerException * if the specified value is null and this map does not permit null * values (optional) */ boolean containsValue(Object value); /** * Returns the value to which the specified key is mapped, or {@code null} if * this map contains no mapping for the key. * *

* More formally, if this map contains a mapping from a key {@code k} to a value * {@code v} such that {@code (key==null ? k==null : key.equals(k))}, then this * method returns {@code v}; otherwise it returns {@code null}. (There can be at * most one such mapping.) * *

* If this map permits null values, then a return value of {@code null} does not * necessarily indicate that the map contains no mapping for the key; * it's also possible that the map explicitly maps the key to {@code * null}. The {@link #containsKey containsKey} operation may be used to * distinguish these two cases. * * @param key * the key whose associated value is to be returned * @return the value to which the specified key is mapped, or {@code null} if * this map contains no mapping for the key * @throws ClassCastException * if the key is of an inappropriate type for this map (optional) * @throws NullPointerException * if the specified key is null and this map does not permit null * keys (optional) */ V get(Object key); // Modification Operations /** * Associates the specified value with the specified key in this map (optional * operation). If the map previously contained a mapping for the key, the old * value is replaced by the specified value. (A map m is said to * contain a mapping for a key k if and only if * {@link #containsKey(Object) m.containsKey(k)} would return true .) * * @param key * key with which the specified value is to be associated * @param value * value to be associated with the specified key * @return the previous value associated with key, or null if * there was no mapping for key. (A null return can * also indicate that the map previously associated null with * key, if the implementation supports null values.) * @throws UnsupportedOperationException * if the put operation is not supported by this map * @throws ClassCastException * if the class of the specified key or value prevents it from being * stored in this map * @throws NullPointerException * if the specified key or value is null and this map does not * permit null keys or values * @throws IllegalArgumentException * if some property of the specified key or value prevents it from * being stored in this map */ V put(K key, V value); /** * Removes the mapping for a key from this map if it is present (optional * operation). More formally, if this map contains a mapping from key k * to value v such that * (key==null ? k==null : key.equals(k)), that mapping is removed. * (The map can contain at most one such mapping.) * *

* Returns the value to which this map previously associated the key, or * null if the map contained no mapping for the key. * *

* If this map permits null values, then a return value of null does * not necessarily indicate that the map contained no mapping for the * key; it's also possible that the map explicitly mapped the key to * null. * *

* The map will not contain a mapping for the specified key once the call * returns. * * @param key * key whose mapping is to be removed from the map * @return the previous value associated with key, or null if * there was no mapping for key. * @throws UnsupportedOperationException * if the remove operation is not supported by this map * @throws ClassCastException * if the key is of an inappropriate type for this map (optional) * @throws NullPointerException * if the specified key is null and this map does not permit null * keys (optional) */ V remove(Object key); // Bulk Operations /** * Copies all of the mappings from the specified map to this map (optional * operation). The effect of this call is equivalent to that of calling * {@link #put(Object,Object) put(k, v)} on this map once for each mapping from * key k to value v in the specified map. The behavior of this * operation is undefined if the specified map is modified while the operation * is in progress. * * @param m * mappings to be stored in this map * @throws UnsupportedOperationException * if the putAll operation is not supported by this map * @throws ClassCastException * if the class of a key or value in the specified map prevents it * from being stored in this map * @throws NullPointerException * if the specified map is null, or if this map does not permit null * keys or values, and the specified map contains null keys or * values * @throws IllegalArgumentException * if some property of a key or value in the specified map prevents * it from being stored in this map */ void putAll(Map m); /** * Removes all of the mappings from this map (optional operation). The map will * be empty after this call returns. * * @throws UnsupportedOperationException * if the clear operation is not supported by this map */ void clear(); // Views /** * Returns a {@link Set} view of the keys contained in this map. The set is * backed by the map, so changes to the map are reflected in the set, and * vice-versa. If the map is modified while an iteration over the set is in * progress (except through the iterator's own remove operation), the * results of the iteration are undefined. The set supports element removal, * which removes the corresponding mapping from the map, via the * Iterator.remove, Set.remove, removeAll, * retainAll, and clear operations. It does not support the * add or addAll operations. * * @return a set view of the keys contained in this map */ Set keySet(); /** * Returns a {@link Collection} view of the values contained in this map. The * collection is backed by the map, so changes to the map are reflected in the * collection, and vice-versa. If the map is modified while an iteration over * the collection is in progress (except through the iterator's own * remove operation), the results of the iteration are undefined. The * collection supports element removal, which removes the corresponding mapping * from the map, via the Iterator.remove, Collection.remove, * removeAll, retainAll and clear operations. It does * not support the add or addAll operations. * * @return a collection view of the values contained in this map */ Collection values(); /** * Returns a {@link Set} view of the mappings contained in this map. The set is * backed by the map, so changes to the map are reflected in the set, and * vice-versa. If the map is modified while an iteration over the set is in * progress (except through the iterator's own remove operation, or * through the setValue operation on a map entry returned by the * iterator) the results of the iteration are undefined. The set supports * element removal, which removes the corresponding mapping from the map, via * the Iterator.remove, Set.remove, removeAll , * retainAll and clear operations. It does not support the * add or addAll operations. * * @return a set view of the mappings contained in this map */ Set> entrySet(); /** * A map entry (key-value pair). The Map.entrySet method returns a * collection-view of the map, whose elements are of this class. The only * way to obtain a reference to a map entry is from the iterator of this * collection-view. These Map.Entry objects are valid only for * the duration of the iteration; more formally, the behavior of a map entry is * undefined if the backing map has been modified after the entry was returned * by the iterator, except through the setValue operation on the map * entry. * * @see Map#entrySet() * @since 1.2 */ interface Entry { /** * Returns the key corresponding to this entry. * * @return the key corresponding to this entry * @throws IllegalStateException * implementations may, but are not required to, throw this * exception if the entry has been removed from the backing map. */ K getKey(); /** * Returns the value corresponding to this entry. If the mapping has been * removed from the backing map (by the iterator's remove operation), * the results of this call are undefined. * * @return the value corresponding to this entry * @throws IllegalStateException * implementations may, but are not required to, throw this * exception if the entry has been removed from the backing map. */ V getValue(); /** * Replaces the value corresponding to this entry with the specified value * (optional operation). (Writes through to the map.) The behavior of this call * is undefined if the mapping has already been removed from the map (by the * iterator's remove operation). * * @param value * new value to be stored in this entry * @return old value corresponding to the entry * @throws UnsupportedOperationException * if the put operation is not supported by the backing map * @throws ClassCastException * if the class of the specified value prevents it from being stored * in the backing map * @throws NullPointerException * if the backing map does not permit null values, and the specified * value is null * @throws IllegalArgumentException * if some property of this value prevents it from being stored in * the backing map * @throws IllegalStateException * implementations may, but are not required to, throw this * exception if the entry has been removed from the backing map. */ V setValue(V value); /** * Compares the specified object with this entry for equality. Returns * true if the given object is also a map entry and the two entries * represent the same mapping. More formally, two entries e1 and * e2 represent the same mapping if * * 

		 * (e1.getKey() == null ? e2.getKey() == null : e1.getKey().equals(e2.getKey()))
		 * 		&& (e1.getValue() == null ? e2.getValue() == null : e1.getValue().equals(e2.getValue()))
		 *
* * This ensures that the equals method works properly across different * implementations of the Map.Entry interface. * * @param o * object to be compared for equality with this map entry * @return true if the specified object is equal to this map entry */ boolean equals(Object o); /** * Returns the hash code value for this map entry. The hash code of a map entry * e is defined to be: * * 
		 * (e.getKey() == null ? 0 : e.getKey().hashCode()) ˆ (e.getValue() == null ? 0 : e.getValue().hashCode())
		 *
* * This ensures that e1.equals(e2) implies that * e1.hashCode()==e2.hashCode() for any two Entries e1 and * e2, as required by the general contract of Object.hashCode. * * @return the hash code value for this map entry * @see Object#hashCode() * @see Object#equals(Object) * @see #equals(Object) */ int hashCode(); } // Comparison and hashing /** * Compares the specified object with this map for equality. Returns * true if the given object is also a map and the two maps represent * the same mappings. More formally, two maps m1 and m2 * represent the same mappings if m1.entrySet().equals(m2.entrySet()). * This ensures that the equals method works properly across different * implementations of the Map interface. * * @param o * object to be compared for equality with this map * @return true if the specified object is equal to this map */ boolean equals(Object o); /** * Returns the hash code value for this map. The hash code of a map is defined * to be the sum of the hash codes of each entry in the map's * entrySet() view. This ensures that m1.equals(m2) implies * that m1.hashCode()==m2.hashCode() for any two maps m1 and * m2, as required by the general contract of {@link Object#hashCode}. * * @return the hash code value for this map * @see Map.Entry#hashCode() * @see Object#equals(Object) * @see #equals(Object) */ int hashCode(); }