/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * <tt>removeAll</tt>, <tt>retainAll</tt> and <tt>clear</tt> * operations. It does not support the <tt>add</tt> or * <tt>addAll</tt> operations. * * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The <tt>Map.Entry</tt> elements returned by * <tt>iterator.next()</tt> do <em>not</em> support the * <tt>setValue</tt> operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet es = entrySet; return (es != null) ? es : (entrySet = new EntrySet(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * <tt>removeAll</tt>, <tt>retainAll</tt> and <tt>clear</tt> * operations. It does not support the <tt>add</tt> or * <tt>addAll</tt> operations. * * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The <tt>Map.Entry</tt> elements returned by * <tt>iterator.next()</tt> do <em>not</em> support the * <tt>setValue</tt> operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet es = entrySet; return (es != null) ? es : (entrySet = new EntrySet(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet(this)); }
public Set<Entry<K,V>> entrySet() { Set<Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }
/** * Returns a {@link Set} view of the mappings contained in this map. * The set's iterator returns the entries in ascending key order. * The set is backed by the map, so changes to the map are * reflected in the set, and vice-versa. The set supports element * removal, which removes the corresponding mapping from the map, * via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} * operations. It does not support the {@code add} or * {@code addAll} operations. * * <p>The view's {@code iterator} is a "weakly consistent" iterator * that will never throw {@link ConcurrentModificationException}, * and guarantees to traverse elements as they existed upon * construction of the iterator, and may (but is not guaranteed to) * reflect any modifications subsequent to construction. * * <p>The {@code Map.Entry} elements returned by * {@code iterator.next()} do <em>not</em> support the * {@code setValue} operation. * * @return a set view of the mappings contained in this map, * sorted in ascending key order */ public Set<Map.Entry<K,V>> entrySet() { EntrySet<K,V> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet<K,V>(this)); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this)); }