ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/AbstractMap.java

Comparing jsr166/src/main/java/util/AbstractMap.java (file contents):
Revision 1.25 by jsr166, Tue Sep 11 15:13:59 2007 UTC vs.
Revision 1.27 by jsr166, Sun May 18 23:59:57 2008 UTC

#	Line 60 | Line 60 | import java.util.Map.Entry;
60		*
61		* @author  Josh Bloch
62		* @author  Neal Gafter
63	–	* @version %I%, %G%
63		* @see Map
64		* @see Collection
65		* @since 1.2
#	Line 82 | Line 81 | public abstract class AbstractMap<K,V> i
81		* <p>This implementation returns <tt>entrySet().size()</tt>.
82		*/
83		public int size() {
84	<	return entrySet().size();
84	>	return entrySet().size();
85		}
86
87		/**
#	Line 91 | Line 90 | public abstract class AbstractMap<K,V> i
90		* <p>This implementation returns <tt>size() == 0</tt>.
91		*/
92		public boolean isEmpty() {
93	<	return size() == 0;
93	>	return size() == 0;
94		}
95
96		/**
#	Line 107 | Line 106 | public abstract class AbstractMap<K,V> i
106		* @throws NullPointerException {@inheritDoc}
107		*/
108		public boolean containsValue(Object value) {
109	<	Iterator<Entry<K,V>> i = entrySet().iterator();
110	<	if (value==null) {
111	<	while (i.hasNext()) {
112	<	Entry<K,V> e = i.next();
113	<	if (e.getValue()==null)
114	<	return true;
115	<	}
116	<	} else {
117	<	while (i.hasNext()) {
118	<	Entry<K,V> e = i.next();
119	<	if (value.equals(e.getValue()))
120	<	return true;
121	<	}
122	<	}
123	<	return false;
109	>	Iterator<Entry<K,V>> i = entrySet().iterator();
110	>	if (value==null) {
111	>	while (i.hasNext()) {
112	>	Entry<K,V> e = i.next();
113	>	if (e.getValue()==null)
114	>	return true;
115	>	}
116	>	} else {
117	>	while (i.hasNext()) {
118	>	Entry<K,V> e = i.next();
119	>	if (value.equals(e.getValue()))
120	>	return true;
121	>	}
122	>	}
123	>	return false;
124		}
125
126		/**
#	Line 138 | Line 137 | public abstract class AbstractMap<K,V> i
137		* @throws NullPointerException {@inheritDoc}
138		*/
139		public boolean containsKey(Object key) {
140	<	Iterator<Map.Entry<K,V>> i = entrySet().iterator();
141	<	if (key==null) {
142	<	while (i.hasNext()) {
143	<	Entry<K,V> e = i.next();
144	<	if (e.getKey()==null)
145	<	return true;
146	<	}
147	<	} else {
148	<	while (i.hasNext()) {
149	<	Entry<K,V> e = i.next();
150	<	if (key.equals(e.getKey()))
151	<	return true;
152	<	}
153	<	}
154	<	return false;
140	>	Iterator<Map.Entry<K,V>> i = entrySet().iterator();
141	>	if (key==null) {
142	>	while (i.hasNext()) {
143	>	Entry<K,V> e = i.next();
144	>	if (e.getKey()==null)
145	>	return true;
146	>	}
147	>	} else {
148	>	while (i.hasNext()) {
149	>	Entry<K,V> e = i.next();
150	>	if (key.equals(e.getKey()))
151	>	return true;
152	>	}
153	>	}
154	>	return false;
155		}
156
157		/**
#	Line 169 | Line 168 | public abstract class AbstractMap<K,V> i
168		* @throws NullPointerException          {@inheritDoc}
169		*/
170		public V get(Object key) {
171	<	Iterator<Entry<K,V>> i = entrySet().iterator();
172	<	if (key==null) {
173	<	while (i.hasNext()) {
174	<	Entry<K,V> e = i.next();
175	<	if (e.getKey()==null)
176	<	return e.getValue();
177	<	}
178	<	} else {
179	<	while (i.hasNext()) {
180	<	Entry<K,V> e = i.next();
181	<	if (key.equals(e.getKey()))
182	<	return e.getValue();
183	<	}
184	<	}
185	<	return null;
171	>	Iterator<Entry<K,V>> i = entrySet().iterator();
172	>	if (key==null) {
173	>	while (i.hasNext()) {
174	>	Entry<K,V> e = i.next();
175	>	if (e.getKey()==null)
176	>	return e.getValue();
177	>	}
178	>	} else {
179	>	while (i.hasNext()) {
180	>	Entry<K,V> e = i.next();
181	>	if (key.equals(e.getKey()))
182	>	return e.getValue();
183	>	}
184	>	}
185	>	return null;
186		}
187
188
#	Line 201 | Line 200 | public abstract class AbstractMap<K,V> i
200		* @throws IllegalArgumentException      {@inheritDoc}
201		*/
202		public V put(K key, V value) {
203	<	throw new UnsupportedOperationException();
203	>	throw new UnsupportedOperationException();
204		}
205
206		/**
#	Line 226 | Line 225 | public abstract class AbstractMap<K,V> i
225		* @throws NullPointerException          {@inheritDoc}
226		*/
227		public V remove(Object key) {
228	<	Iterator<Entry<K,V>> i = entrySet().iterator();
229	<	Entry<K,V> correctEntry = null;
230	<	if (key==null) {
231	<	while (correctEntry==null && i.hasNext()) {
232	<	Entry<K,V> e = i.next();
233	<	if (e.getKey()==null)
234	<	correctEntry = e;
235	<	}
236	<	} else {
237	<	while (correctEntry==null && i.hasNext()) {
238	<	Entry<K,V> e = i.next();
239	<	if (key.equals(e.getKey()))
240	<	correctEntry = e;
241	<	}
242	<	}
243	<
244	<	V oldValue = null;
245	<	if (correctEntry !=null) {
246	<	oldValue = correctEntry.getValue();
247	<	i.remove();
248	<	}
249	<	return oldValue;
228	>	Iterator<Entry<K,V>> i = entrySet().iterator();
229	>	Entry<K,V> correctEntry = null;
230	>	if (key==null) {
231	>	while (correctEntry==null && i.hasNext()) {
232	>	Entry<K,V> e = i.next();
233	>	if (e.getKey()==null)
234	>	correctEntry = e;
235	>	}
236	>	} else {
237	>	while (correctEntry==null && i.hasNext()) {
238	>	Entry<K,V> e = i.next();
239	>	if (key.equals(e.getKey()))
240	>	correctEntry = e;
241	>	}
242	>	}
243	>
244	>	V oldValue = null;
245	>	if (correctEntry !=null) {
246	>	oldValue = correctEntry.getValue();
247	>	i.remove();
248	>	}
249	>	return oldValue;
250		}
251
252
#	Line 286 | Line 285 | public abstract class AbstractMap<K,V> i
285		* @throws UnsupportedOperationException {@inheritDoc}
286		*/
287		public void clear() {
288	<	entrySet().clear();
288	>	entrySet().clear();
289		}
290
291
#	Line 316 | Line 315 | public abstract class AbstractMap<K,V> i
315		* method will not all return the same set.
316		*/
317		public Set<K> keySet() {
318	<	if (keySet == null) {
319	<	keySet = new AbstractSet<K>() {
320	<	public Iterator<K> iterator() {
321	<	return new Iterator<K>() {
322	<	private Iterator<Entry<K,V>> i = entrySet().iterator();
323	<
324	<	public boolean hasNext() {
325	<	return i.hasNext();
326	<	}
327	<
328	<	public K next() {
329	<	return i.next().getKey();
330	<	}
331	<
332	<	public void remove() {
333	<	i.remove();
334	<	}
318	>	if (keySet == null) {
319	>	keySet = new AbstractSet<K>() {
320	>	public Iterator<K> iterator() {
321	>	return new Iterator<K>() {
322	>	private Iterator<Entry<K,V>> i = entrySet().iterator();
323	>
324	>	public boolean hasNext() {
325	>	return i.hasNext();
326	>	}
327	>
328	>	public K next() {
329	>	return i.next().getKey();
330	>	}
331	>
332	>	public void remove() {
333	>	i.remove();
334	>	}
335		};
336	<	}
336	>	}
337
338	<	public int size() {
339	<	return AbstractMap.this.size();
340	<	}
341	<
342	<	public boolean isEmpty() {
343	<	return AbstractMap.this.isEmpty();
344	<	}
345	<
346	<	public void clear() {
347	<	AbstractMap.this.clear();
348	<	}
349	<
350	<	public boolean contains(Object k) {
351	<	return AbstractMap.this.containsKey(k);
352	<	}
353	<	};
354	<	}
355	<	return keySet;
338	>	public int size() {
339	>	return AbstractMap.this.size();
340	>	}
341	>
342	>	public boolean isEmpty() {
343	>	return AbstractMap.this.isEmpty();
344	>	}
345	>
346	>	public void clear() {
347	>	AbstractMap.this.clear();
348	>	}
349	>
350	>	public boolean contains(Object k) {
351	>	return AbstractMap.this.containsKey(k);
352	>	}
353	>	};
354	>	}
355	>	return keySet;
356		}
357
358		/**
#	Line 372 | Line 371 | public abstract class AbstractMap<K,V> i
371		* method will not all return the same collection.
372		*/
373		public Collection<V> values() {
374	<	if (values == null) {
375	<	values = new AbstractCollection<V>() {
376	<	public Iterator<V> iterator() {
377	<	return new Iterator<V>() {
378	<	private Iterator<Entry<K,V>> i = entrySet().iterator();
379	<
380	<	public boolean hasNext() {
381	<	return i.hasNext();
382	<	}
383	<
384	<	public V next() {
385	<	return i.next().getValue();
386	<	}
387	<
388	<	public void remove() {
389	<	i.remove();
390	<	}
374	>	if (values == null) {
375	>	values = new AbstractCollection<V>() {
376	>	public Iterator<V> iterator() {
377	>	return new Iterator<V>() {
378	>	private Iterator<Entry<K,V>> i = entrySet().iterator();
379	>
380	>	public boolean hasNext() {
381	>	return i.hasNext();
382	>	}
383	>
384	>	public V next() {
385	>	return i.next().getValue();
386	>	}
387	>
388	>	public void remove() {
389	>	i.remove();
390	>	}
391		};
392		}
393
394	<	public int size() {
395	<	return AbstractMap.this.size();
396	<	}
397	<
398	<	public boolean isEmpty() {
399	<	return AbstractMap.this.isEmpty();
400	<	}
401	<
402	<	public void clear() {
403	<	AbstractMap.this.clear();
404	<	}
405	<
406	<	public boolean contains(Object v) {
407	<	return AbstractMap.this.containsValue(v);
408	<	}
409	<	};
410	<	}
411	<	return values;
394	>	public int size() {
395	>	return AbstractMap.this.size();
396	>	}
397	>
398	>	public boolean isEmpty() {
399	>	return AbstractMap.this.isEmpty();
400	>	}
401	>
402	>	public void clear() {
403	>	AbstractMap.this.clear();
404	>	}
405	>
406	>	public boolean contains(Object v) {
407	>	return AbstractMap.this.containsValue(v);
408	>	}
409	>	};
410	>	}
411	>	return values;
412		}
413
414		public abstract Set<Entry<K,V>> entrySet();
#	Line 439 | Line 438 | public abstract class AbstractMap<K,V> i
438		* @return <tt>true</tt> if the specified object is equal to this map
439		*/
440		public boolean equals(Object o) {
441	<	if (o == this)
442	<	return true;
441	>	if (o == this)
442	>	return true;
443
444	<	if (!(o instanceof Map))
445	<	return false;
446	<	Map<K,V> m = (Map<K,V>) o;
447	<	if (m.size() != size())
448	<	return false;
444	>	if (!(o instanceof Map))
445	>	return false;
446	>	Map<K,V> m = (Map<K,V>) o;
447	>	if (m.size() != size())
448	>	return false;
449
450		try {
451		Iterator<Entry<K,V>> i = entrySet().iterator();
452		while (i.hasNext()) {
453		Entry<K,V> e = i.next();
454	<	K key = e.getKey();
454	>	K key = e.getKey();
455		V value = e.getValue();
456		if (value == null) {
457		if (!(m.get(key)==null && m.containsKey(key)))
#	Line 468 | Line 467 | public abstract class AbstractMap<K,V> i
467		return false;
468		}
469
470	<	return true;
470	>	return true;
471		}
472
473		/**
#	Line 489 | Line 488 | public abstract class AbstractMap<K,V> i
488		* @see Set#equals(Object)
489		*/
490		public int hashCode() {
491	<	int h = 0;
492	<	Iterator<Entry<K,V>> i = entrySet().iterator();
493	<	while (i.hasNext())
494	<	h += i.next().hashCode();
495	<	return h;
491	>	int h = 0;
492	>	Iterator<Entry<K,V>> i = entrySet().iterator();
493	>	while (i.hasNext())
494	>	h += i.next().hashCode();
495	>	return h;
496		}
497
498		/**
#	Line 509 | Line 508 | public abstract class AbstractMap<K,V> i
508		* @return a string representation of this map
509		*/
510		public String toString() {
511	<	Iterator<Entry<K,V>> i = entrySet().iterator();
512	<	if (! i.hasNext())
513	<	return "{}";
514	<
515	<	StringBuilder sb = new StringBuilder();
516	<	sb.append('{');
517	<	for (;;) {
518	<	Entry<K,V> e = i.next();
519	<	K key = e.getKey();
520	<	V value = e.getValue();
521	<	sb.append(key   == this ? "(this Map)" : key);
522	<	sb.append('=');
523	<	sb.append(value == this ? "(this Map)" : value);
524	<	if (! i.hasNext())
525	<	return sb.append('}').toString();
526	<	sb.append(", ");
527	<	}
511	>	Iterator<Entry<K,V>> i = entrySet().iterator();
512	>	if (! i.hasNext())
513	>	return "{}";
514	>
515	>	StringBuilder sb = new StringBuilder();
516	>	sb.append('{');
517	>	for (;;) {
518	>	Entry<K,V> e = i.next();
519	>	K key = e.getKey();
520	>	V value = e.getValue();
521	>	sb.append(key   == this ? "(this Map)" : key);
522	>	sb.append('=');
523	>	sb.append(value == this ? "(this Map)" : value);
524	>	if (! i.hasNext())
525	>	return sb.append('}').toString();
526	>	sb.append(", ");
527	>	}
528		}
529
530		/**
#	Line 568 | Line 567 | public abstract class AbstractMap<K,V> i
567		* @since 1.6
568		*/
569		public static class SimpleEntry<K,V>
570	<	implements Entry<K,V>, java.io.Serializable
570	>	implements Entry<K,V>, java.io.Serializable
571		{
572	<	private static final long serialVersionUID = -8499721149061103585L;
572	>	private static final long serialVersionUID = -8499721149061103585L;
573
574	<	private final K key;
575	<	private V value;
574	>	private final K key;
575	>	private V value;
576
577		/**
578		* Creates an entry representing a mapping from the specified
#	Line 582 | Line 581 | public abstract class AbstractMap<K,V> i
581		* @param key the key represented by this entry
582		* @param value the value represented by this entry
583		*/
584	<	public SimpleEntry(K key, V value) {
585	<	this.key   = key;
584	>	public SimpleEntry(K key, V value) {
585	>	this.key   = key;
586		this.value = value;
587	<	}
587	>	}
588
589		/**
590		* Creates an entry representing the same mapping as the
#	Line 593 | Line 592 | public abstract class AbstractMap<K,V> i
592		*
593		* @param entry the entry to copy
594		*/
595	<	public SimpleEntry(Entry<? extends K, ? extends V> entry) {
596	<	this.key   = entry.getKey();
595	>	public SimpleEntry(Entry<? extends K, ? extends V> entry) {
596	>	this.key   = entry.getKey();
597		this.value = entry.getValue();
598	<	}
598	>	}
599
600	<	/**
601	<	* Returns the key corresponding to this entry.
602	<	*
603	<	* @return the key corresponding to this entry
604	<	*/
605	<	public K getKey() {
606	<	return key;
607	<	}
608	<
609	<	/**
610	<	* Returns the value corresponding to this entry.
611	<	*
612	<	* @return the value corresponding to this entry
613	<	*/
614	<	public V getValue() {
615	<	return value;
616	<	}
617	<
618	<	/**
619	<	* Replaces the value corresponding to this entry with the specified
620	<	* value.
621	<	*
622	<	* @param value new value to be stored in this entry
623	<	* @return the old value corresponding to the entry
624	<	*/
625	<	public V setValue(V value) {
626	<	V oldValue = this.value;
627	<	this.value = value;
628	<	return oldValue;
629	<	}
630	<
631	<	/**
632	<	* Compares the specified object with this entry for equality.
633	<	* Returns {@code true} if the given object is also a map entry and
634	<	* the two entries represent the same mapping.  More formally, two
635	<	* entries {@code e1} and {@code e2} represent the same mapping
636	<	* if<pre>
637	<	*   (e1.getKey()==null ?
638	<	*    e2.getKey()==null :
639	<	*    e1.getKey().equals(e2.getKey()))
640	<	*   &amp;&amp;
641	<	*   (e1.getValue()==null ?
642	<	*    e2.getValue()==null :
643	<	*    e1.getValue().equals(e2.getValue()))</pre>
644	<	* This ensures that the {@code equals} method works properly across
645	<	* different implementations of the {@code Map.Entry} interface.
646	<	*
647	<	* @param o object to be compared for equality with this map entry
648	<	* @return {@code true} if the specified object is equal to this map
649	<	*         entry
650	<	* @see    #hashCode
651	<	*/
652	<	public boolean equals(Object o) {
653	<	if (!(o instanceof Map.Entry))
654	<	return false;
655	<	Map.Entry e = (Map.Entry)o;
656	<	return eq(key, e.getKey()) && eq(value, e.getValue());
657	<	}
658	<
659	<	/**
660	<	* Returns the hash code value for this map entry.  The hash code
661	<	* of a map entry {@code e} is defined to be: <pre>
662	<	*   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
663	<	*   (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
664	<	* This ensures that {@code e1.equals(e2)} implies that
665	<	* {@code e1.hashCode()==e2.hashCode()} for any two Entries
666	<	* {@code e1} and {@code e2}, as required by the general
667	<	* contract of {@link Object#hashCode}.
668	<	*
669	<	* @return the hash code value for this map entry
670	<	* @see    #equals
671	<	*/
672	<	public int hashCode() {
673	<	return (key   == null ? 0 :   key.hashCode()) ^
674	<	(value == null ? 0 : value.hashCode());
675	<	}
600	>	/**
601	>	* Returns the key corresponding to this entry.
602	>	*
603	>	* @return the key corresponding to this entry
604	>	*/
605	>	public K getKey() {
606	>	return key;
607	>	}
608	>
609	>	/**
610	>	* Returns the value corresponding to this entry.
611	>	*
612	>	* @return the value corresponding to this entry
613	>	*/
614	>	public V getValue() {
615	>	return value;
616	>	}
617	>
618	>	/**
619	>	* Replaces the value corresponding to this entry with the specified
620	>	* value.
621	>	*
622	>	* @param value new value to be stored in this entry
623	>	* @return the old value corresponding to the entry
624	>	*/
625	>	public V setValue(V value) {
626	>	V oldValue = this.value;
627	>	this.value = value;
628	>	return oldValue;
629	>	}
630	>
631	>	/**
632	>	* Compares the specified object with this entry for equality.
633	>	* Returns {@code true} if the given object is also a map entry and
634	>	* the two entries represent the same mapping.  More formally, two
635	>	* entries {@code e1} and {@code e2} represent the same mapping
636	>	* if<pre>
637	>	*   (e1.getKey()==null ?
638	>	*    e2.getKey()==null :
639	>	*    e1.getKey().equals(e2.getKey()))
640	>	*   &amp;&amp;
641	>	*   (e1.getValue()==null ?
642	>	*    e2.getValue()==null :
643	>	*    e1.getValue().equals(e2.getValue()))</pre>
644	>	* This ensures that the {@code equals} method works properly across
645	>	* different implementations of the {@code Map.Entry} interface.
646	>	*
647	>	* @param o object to be compared for equality with this map entry
648	>	* @return {@code true} if the specified object is equal to this map
649	>	*         entry
650	>	* @see    #hashCode
651	>	*/
652	>	public boolean equals(Object o) {
653	>	if (!(o instanceof Map.Entry))
654	>	return false;
655	>	Map.Entry e = (Map.Entry)o;
656	>	return eq(key, e.getKey()) && eq(value, e.getValue());
657	>	}
658	>
659	>	/**
660	>	* Returns the hash code value for this map entry.  The hash code
661	>	* of a map entry {@code e} is defined to be: <pre>
662	>	*   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
663	>	*   (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
664	>	* This ensures that {@code e1.equals(e2)} implies that
665	>	* {@code e1.hashCode()==e2.hashCode()} for any two Entries
666	>	* {@code e1} and {@code e2}, as required by the general
667	>	* contract of {@link Object#hashCode}.
668	>	*
669	>	* @return the hash code value for this map entry
670	>	* @see    #equals
671	>	*/
672	>	public int hashCode() {
673	>	return (key   == null ? 0 :   key.hashCode()) ^
674	>	(value == null ? 0 : value.hashCode());
675	>	}
676
677		/**
678		* Returns a String representation of this map entry.  This
#	Line 683 | Line 682 | public abstract class AbstractMap<K,V> i
682		*
683		* @return a String representation of this map entry
684		*/
685	<	public String toString() {
686	<	return key + "=" + value;
687	<	}
685	>	public String toString() {
686	>	return key + "=" + value;
687	>	}
688
689		}
690
#	Line 698 | Line 697 | public abstract class AbstractMap<K,V> i
697		* @since 1.6
698		*/
699		public static class SimpleImmutableEntry<K,V>
700	<	implements Entry<K,V>, java.io.Serializable
700	>	implements Entry<K,V>, java.io.Serializable
701		{
702	<	private static final long serialVersionUID = 7138329143949025153L;
702	>	private static final long serialVersionUID = 7138329143949025153L;
703
704	<	private final K key;
705	<	private final V value;
704	>	private final K key;
705	>	private final V value;
706
707		/**
708		* Creates an entry representing a mapping from the specified
#	Line 712 | Line 711 | public abstract class AbstractMap<K,V> i
711		* @param key the key represented by this entry
712		* @param value the value represented by this entry
713		*/
714	<	public SimpleImmutableEntry(K key, V value) {
715	<	this.key   = key;
714	>	public SimpleImmutableEntry(K key, V value) {
715	>	this.key   = key;
716		this.value = value;
717	<	}
717	>	}
718
719		/**
720		* Creates an entry representing the same mapping as the
#	Line 723 | Line 722 | public abstract class AbstractMap<K,V> i
722		*
723		* @param entry the entry to copy
724		*/
725	<	public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
726	<	this.key   = entry.getKey();
725	>	public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
726	>	this.key   = entry.getKey();
727		this.value = entry.getValue();
728	<	}
728	>	}
729	>
730	>	/**
731	>	* Returns the key corresponding to this entry.
732	>	*
733	>	* @return the key corresponding to this entry
734	>	*/
735	>	public K getKey() {
736	>	return key;
737	>	}
738	>
739	>	/**
740	>	* Returns the value corresponding to this entry.
741	>	*
742	>	* @return the value corresponding to this entry
743	>	*/
744	>	public V getValue() {
745	>	return value;
746	>	}
747
748	<	/**
749	<	* Returns the key corresponding to this entry.
750	<	*
734	<	* @return the key corresponding to this entry
735	<	*/
736	<	public K getKey() {
737	<	return key;
738	<	}
739	<
740	<	/**
741	<	* Returns the value corresponding to this entry.
742	<	*
743	<	* @return the value corresponding to this entry
744	<	*/
745	<	public V getValue() {
746	<	return value;
747	<	}
748	<
749	<	/**
750	<	* Replaces the value corresponding to this entry with the specified
751	<	* value (optional operation).  This implementation simply throws
748	>	/**
749	>	* Replaces the value corresponding to this entry with the specified
750	>	* value (optional operation).  This implementation simply throws
751		* <tt>UnsupportedOperationException</tt>, as this class implements
752		* an <i>immutable</i> map entry.
753	<	*
754	<	* @param value new value to be stored in this entry
755	<	* @return (Does not return)
756	<	* @throws UnsupportedOperationException always
753	>	*
754	>	* @param value new value to be stored in this entry
755	>	* @return (Does not return)
756	>	* @throws UnsupportedOperationException always
757		*/
758	<	public V setValue(V value) {
758	>	public V setValue(V value) {
759		throw new UnsupportedOperationException();
760		}
761
762	<	/**
763	<	* Compares the specified object with this entry for equality.
764	<	* Returns {@code true} if the given object is also a map entry and
765	<	* the two entries represent the same mapping.  More formally, two
766	<	* entries {@code e1} and {@code e2} represent the same mapping
767	<	* if<pre>
768	<	*   (e1.getKey()==null ?
769	<	*    e2.getKey()==null :
770	<	*    e1.getKey().equals(e2.getKey()))
771	<	*   &amp;&amp;
772	<	*   (e1.getValue()==null ?
773	<	*    e2.getValue()==null :
774	<	*    e1.getValue().equals(e2.getValue()))</pre>
775	<	* This ensures that the {@code equals} method works properly across
776	<	* different implementations of the {@code Map.Entry} interface.
777	<	*
778	<	* @param o object to be compared for equality with this map entry
779	<	* @return {@code true} if the specified object is equal to this map
780	<	*         entry
781	<	* @see    #hashCode
782	<	*/
783	<	public boolean equals(Object o) {
784	<	if (!(o instanceof Map.Entry))
785	<	return false;
786	<	Map.Entry e = (Map.Entry)o;
787	<	return eq(key, e.getKey()) && eq(value, e.getValue());
788	<	}
789	<
790	<	/**
791	<	* Returns the hash code value for this map entry.  The hash code
792	<	* of a map entry {@code e} is defined to be: <pre>
793	<	*   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
794	<	*   (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
795	<	* This ensures that {@code e1.equals(e2)} implies that
796	<	* {@code e1.hashCode()==e2.hashCode()} for any two Entries
797	<	* {@code e1} and {@code e2}, as required by the general
798	<	* contract of {@link Object#hashCode}.
799	<	*
800	<	* @return the hash code value for this map entry
801	<	* @see    #equals
802	<	*/
803	<	public int hashCode() {
804	<	return (key   == null ? 0 :   key.hashCode()) ^
805	<	(value == null ? 0 : value.hashCode());
806	<	}
762	>	/**
763	>	* Compares the specified object with this entry for equality.
764	>	* Returns {@code true} if the given object is also a map entry and
765	>	* the two entries represent the same mapping.  More formally, two
766	>	* entries {@code e1} and {@code e2} represent the same mapping
767	>	* if<pre>
768	>	*   (e1.getKey()==null ?
769	>	*    e2.getKey()==null :
770	>	*    e1.getKey().equals(e2.getKey()))
771	>	*   &amp;&amp;
772	>	*   (e1.getValue()==null ?
773	>	*    e2.getValue()==null :
774	>	*    e1.getValue().equals(e2.getValue()))</pre>
775	>	* This ensures that the {@code equals} method works properly across
776	>	* different implementations of the {@code Map.Entry} interface.
777	>	*
778	>	* @param o object to be compared for equality with this map entry
779	>	* @return {@code true} if the specified object is equal to this map
780	>	*         entry
781	>	* @see    #hashCode
782	>	*/
783	>	public boolean equals(Object o) {
784	>	if (!(o instanceof Map.Entry))
785	>	return false;
786	>	Map.Entry e = (Map.Entry)o;
787	>	return eq(key, e.getKey()) && eq(value, e.getValue());
788	>	}
789	>
790	>	/**
791	>	* Returns the hash code value for this map entry.  The hash code
792	>	* of a map entry {@code e} is defined to be: <pre>
793	>	*   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
794	>	*   (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
795	>	* This ensures that {@code e1.equals(e2)} implies that
796	>	* {@code e1.hashCode()==e2.hashCode()} for any two Entries
797	>	* {@code e1} and {@code e2}, as required by the general
798	>	* contract of {@link Object#hashCode}.
799	>	*
800	>	* @return the hash code value for this map entry
801	>	* @see    #equals
802	>	*/
803	>	public int hashCode() {
804	>	return (key   == null ? 0 :   key.hashCode()) ^
805	>	(value == null ? 0 : value.hashCode());
806	>	}
807
808		/**
809		* Returns a String representation of this map entry.  This
#	Line 814 | Line 813 | public abstract class AbstractMap<K,V> i
813		*
814		* @return a String representation of this map entry
815		*/
816	<	public String toString() {
817	<	return key + "=" + value;
818	<	}
816	>	public String toString() {
817	>	return key + "=" + value;
818	>	}
819
820		}
821

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines