public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
/** * 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 <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 boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es = entrySetView; return (es != null) ? es : (entrySetView = new EntrySet(this)); }
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; try { return containsAll(c) && c.containsAll(this); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } public Object[] toArray() { return toList(this).toArray(); }