LinkedHashSet
public
class
LinkedHashSet
extends HashSet<E>
implements
Set<E>,
Cloneable,
Serializable
Hash table and linked list implementation of the Set
interface,
with predictable iteration order. This implementation differs from
HashSet
in that it maintains a doubly-linked list running through
all of its entries. This linked list defines the iteration ordering,
which is the order in which elements were inserted into the set
(insertion-order). Note that insertion order is not affected
if an element is re-inserted into the set. (An element e
is reinserted into a set s
if s.add(e)
is invoked when
s.contains(e)
would return true
immediately prior to
the invocation.)
This implementation spares its clients from the unspecified, generally
chaotic ordering provided by HashSet
, without incurring the
increased cost associated with TreeSet
. It can be used to
produce a copy of a set that has the same order as the original, regardless
of the original set's implementation:
void foo(Set<String> s) {
Set<String> copy = new LinkedHashSet<>(s);
...
}
This technique is particularly useful if a module takes a set on input,
copies it, and later returns results whose order is determined by that of
the copy. (Clients generally appreciate having things returned in the same
order they were presented.)
This class provides all of the optional Set
operations, and
permits null elements. Like HashSet
, it provides constant-time
performance for the basic operations (add
, contains
and
remove
), assuming the hash function disperses elements
properly among the buckets. Performance is likely to be just slightly
below that of HashSet
, due to the added expense of maintaining the
linked list, with one exception: Iteration over a LinkedHashSet
requires time proportional to the size of the set, regardless of
its capacity. Iteration over a HashSet
is likely to be more
expensive, requiring time proportional to its capacity.
A linked hash set has two parameters that affect its performance:
initial capacity and load factor. They are defined precisely
as for HashSet
. Note, however, that the penalty for choosing an
excessively high value for initial capacity is less severe for this class
than for HashSet
, as iteration times for this class are unaffected
by capacity.
Note that this implementation is not synchronized.
If multiple threads access a linked hash set concurrently, and at least
one of the threads modifies the set, it must be synchronized
externally. This is typically accomplished by synchronizing on some
object that naturally encapsulates the set.
If no such object exists, the set should be "wrapped" using the
Collections.synchronizedSet
method. This is best done at creation time, to prevent accidental
unsynchronized access to the set:
Set s = Collections.synchronizedSet(new LinkedHashSet(...));
The iterators returned by this class's iterator
method are
fail-fast: if the set is modified at any time after the iterator
is created, in any way except through the iterator's own remove
method, the iterator will throw a ConcurrentModificationException
.
Thus, in the face of concurrent modification, the iterator fails quickly
and cleanly, rather than risking arbitrary, non-deterministic behavior at
an undetermined time in the future.
Note that the fail-fast behavior of an iterator cannot be guaranteed
as it is, generally speaking, impossible to make any hard guarantees in the
presence of unsynchronized concurrent modification. Fail-fast iterators
throw ConcurrentModificationException
on a best-effort basis.
Therefore, it would be wrong to write a program that depended on this
exception for its correctness: the fail-fast behavior of iterators
should be used only to detect bugs.
This class is a member of the
Java Collections Framework.
Summary
Public constructors |
LinkedHashSet(int initialCapacity, float loadFactor)
Constructs a new, empty linked hash set with the specified initial
capacity and load factor.
|
LinkedHashSet(int initialCapacity)
Constructs a new, empty linked hash set with the specified initial
capacity and the default load factor (0.75).
|
LinkedHashSet()
Constructs a new, empty linked hash set with the default initial
capacity (16) and load factor (0.75).
|
LinkedHashSet(Collection<? extends E> c)
Constructs a new linked hash set with the same elements as the
specified collection.
|
Inherited methods |
From class
java.util.HashSet
boolean
|
add(E e)
Adds the specified element to this set if it is not already present.
|
void
|
clear()
Removes all of the elements from this set.
|
Object
|
clone()
Returns a shallow copy of this HashSet instance: the elements
themselves are not cloned.
|
boolean
|
contains(Object o)
Returns true if this set contains the specified element.
|
boolean
|
isEmpty()
Returns true if this set contains no elements.
|
Iterator<E>
|
iterator()
Returns an iterator over the elements in this set.
|
boolean
|
remove(Object o)
Removes the specified element from this set if it is present.
|
int
|
size()
Returns the number of elements in this set (its cardinality).
|
Spliterator<E>
|
spliterator()
Creates a late-binding
and fail-fast Spliterator over the elements in this
set.
|
<T>
T[]
|
toArray(T[] a)
Returns an array containing all of the elements in this collection;
the runtime type of the returned array is that of the specified array.
|
Object[]
|
toArray()
Returns an array containing all of the elements in this collection.
|
|
From class
java.util.AbstractSet
boolean
|
equals(Object o)
Compares the specified object with this set for equality.
|
int
|
hashCode()
Returns the hash code value for this set.
|
boolean
|
removeAll(Collection<?> c)
Removes from this set all of its elements that are contained in the
specified collection (optional operation).
|
|
From class
java.util.AbstractCollection
boolean
|
add(E e)
Ensures that this collection contains the specified element (optional
operation).
|
boolean
|
addAll(Collection<? extends E> c)
Adds all of the elements in the specified collection to this collection
(optional operation).
|
void
|
clear()
Removes all of the elements from this collection (optional operation).
|
boolean
|
contains(Object o)
Returns true if this collection contains the specified element.
|
boolean
|
containsAll(Collection<?> c)
Returns true if this collection contains all of the elements
in the specified collection.
|
boolean
|
isEmpty()
Returns true if this collection contains no elements.
|
abstract
Iterator<E>
|
iterator()
Returns an iterator over the elements contained in this collection.
|
boolean
|
remove(Object o)
Removes a single instance of the specified element from this
collection, if it is present (optional operation).
|
boolean
|
removeAll(Collection<?> c)
Removes all of this collection's elements that are also contained in the
specified collection (optional operation).
|
boolean
|
retainAll(Collection<?> c)
Retains only the elements in this collection that are contained in the
specified collection (optional operation).
|
abstract
int
|
size()
Returns the number of elements in this collection.
|
<T>
T[]
|
toArray(T[] a)
Returns an array containing all of the elements in this collection;
the runtime type of the returned array is that of the specified array.
|
Object[]
|
toArray()
Returns an array containing all of the elements in this collection.
|
String
|
toString()
Returns a string representation of this collection.
|
|
From class
java.lang.Object
Object
|
clone()
Creates and returns a copy of this object.
|
boolean
|
equals(Object obj)
Indicates whether some other object is "equal to" this one.
|
void
|
finalize()
Called by the garbage collector on an object when garbage collection
determines that there are no more references to the object.
|
final
Class<?>
|
getClass()
Returns the runtime class of this Object .
|
int
|
hashCode()
Returns a hash code value for the object.
|
final
void
|
notify()
Wakes up a single thread that is waiting on this object's
monitor.
|
final
void
|
notifyAll()
Wakes up all threads that are waiting on this object's monitor.
|
String
|
toString()
Returns a string representation of the object.
|
final
void
|
wait(long timeoutMillis, int nanos)
Causes the current thread to wait until it is awakened, typically
by being notified or interrupted, or until a
certain amount of real time has elapsed.
|
final
void
|
wait(long timeoutMillis)
Causes the current thread to wait until it is awakened, typically
by being notified or interrupted, or until a
certain amount of real time has elapsed.
|
final
void
|
wait()
Causes the current thread to wait until it is awakened, typically
by being notified or interrupted.
|
|
From interface
java.util.Set
abstract
boolean
|
add(E e)
Adds the specified element to this set if it is not already present
(optional operation).
|
abstract
boolean
|
addAll(Collection<? extends E> c)
Adds all of the elements in the specified collection to this set if
they're not already present (optional operation).
|
abstract
void
|
clear()
Removes all of the elements from this set (optional operation).
|
abstract
boolean
|
contains(Object o)
Returns true if this set contains the specified element.
|
abstract
boolean
|
containsAll(Collection<?> c)
Returns true if this set contains all of the elements of the
specified collection.
|
static
<E>
Set<E>
|
copyOf(Collection<? extends E> coll)
Returns an unmodifiable Set containing the elements
of the given Collection.
|
abstract
boolean
|
equals(Object o)
Compares the specified object with this set for equality.
|
abstract
int
|
hashCode()
Returns the hash code value for this set.
|
abstract
boolean
|
isEmpty()
Returns true if this set contains no elements.
|
abstract
Iterator<E>
|
iterator()
Returns an iterator over the elements in this set.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3)
Returns an unmodifiable set containing three elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)
Returns an unmodifiable set containing nine elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4, E e5)
Returns an unmodifiable set containing five elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4, E e5, E e6)
Returns an unmodifiable set containing six elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)
Returns an unmodifiable set containing eight elements.
|
static
<E>
Set<E>
|
of(E... elements)
Returns an unmodifiable set containing an arbitrary number of elements.
|
static
<E>
Set<E>
|
of()
Returns an unmodifiable set containing zero elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
Returns an unmodifiable set containing ten elements.
|
static
<E>
Set<E>
|
of(E e1, E e2)
Returns an unmodifiable set containing two elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)
Returns an unmodifiable set containing seven elements.
|
static
<E>
Set<E>
|
of(E e1, E e2, E e3, E e4)
Returns an unmodifiable set containing four elements.
|
static
<E>
Set<E>
|
of(E e1)
Returns an unmodifiable set containing one element.
|
abstract
boolean
|
remove(Object o)
Removes the specified element from this set if it is present
(optional operation).
|
abstract
boolean
|
removeAll(Collection<?> c)
Removes from this set all of its elements that are contained in the
specified collection (optional operation).
|
abstract
boolean
|
retainAll(Collection<?> c)
Retains only the elements in this set that are contained in the
specified collection (optional operation).
|
abstract
int
|
size()
Returns the number of elements in this set (its cardinality).
|
default
Spliterator<E>
|
spliterator()
Creates a Spliterator over the elements in this set.
|
abstract
Object[]
|
toArray()
Returns an array containing all of the elements in this set.
|
abstract
<T>
T[]
|
toArray(T[] a)
Returns an array containing all of the elements in this set; the
runtime type of the returned array is that of the specified array.
|
|
From interface
java.util.Collection
abstract
boolean
|
add(E e)
Ensures that this collection contains the specified element (optional
operation).
|
abstract
boolean
|
addAll(Collection<? extends E> c)
Adds all of the elements in the specified collection to this collection
(optional operation).
|
abstract
void
|
clear()
Removes all of the elements from this collection (optional operation).
|
abstract
boolean
|
contains(Object o)
Returns true if this collection contains the specified element.
|
abstract
boolean
|
containsAll(Collection<?> c)
Returns true if this collection contains all of the elements
in the specified collection.
|
abstract
boolean
|
equals(Object o)
Compares the specified object with this collection for equality.
|
abstract
int
|
hashCode()
Returns the hash code value for this collection.
|
abstract
boolean
|
isEmpty()
Returns true if this collection contains no elements.
|
abstract
Iterator<E>
|
iterator()
Returns an iterator over the elements in this collection.
|
default
Stream<E>
|
parallelStream()
Returns a possibly parallel Stream with this collection as its
source.
|
abstract
boolean
|
remove(Object o)
Removes a single instance of the specified element from this
collection, if it is present (optional operation).
|
abstract
boolean
|
removeAll(Collection<?> c)
Removes all of this collection's elements that are also contained in the
specified collection (optional operation).
|
default
boolean
|
removeIf(Predicate<? super E> filter)
Removes all of the elements of this collection that satisfy the given
predicate.
|
abstract
boolean
|
retainAll(Collection<?> c)
Retains only the elements in this collection that are contained in the
specified collection (optional operation).
|
abstract
int
|
size()
Returns the number of elements in this collection.
|
default
Spliterator<E>
|
spliterator()
Creates a Spliterator over the elements in this collection.
|
default
Stream<E>
|
stream()
Returns a sequential Stream with this collection as its source.
|
abstract
<T>
T[]
|
toArray(T[] a)
Returns an array containing all of the elements in this collection;
the runtime type of the returned array is that of the specified array.
|
abstract
Object[]
|
toArray()
Returns an array containing all of the elements in this collection.
|
default
<T>
T[]
|
toArray(IntFunction<T[]> generator)
Returns an array containing all of the elements in this collection,
using the provided generator function to allocate the returned array.
|
|
|
Public constructors
LinkedHashSet
public LinkedHashSet (int initialCapacity,
float loadFactor)
Constructs a new, empty linked hash set with the specified initial
capacity and load factor.
Parameters |
initialCapacity |
int : the initial capacity of the linked hash set |
loadFactor |
float : the load factor of the linked hash set |
LinkedHashSet
public LinkedHashSet (int initialCapacity)
Constructs a new, empty linked hash set with the specified initial
capacity and the default load factor (0.75).
Parameters |
initialCapacity |
int : the initial capacity of the LinkedHashSet |
LinkedHashSet
public LinkedHashSet ()
Constructs a new, empty linked hash set with the default initial
capacity (16) and load factor (0.75).
LinkedHashSet
public LinkedHashSet (Collection<? extends E> c)
Constructs a new linked hash set with the same elements as the
specified collection. The linked hash set is created with an initial
capacity sufficient to hold the elements in the specified collection
and the default load factor (0.75).
Parameters |
c |
Collection : the collection whose elements are to be placed into
this set |
Public methods
spliterator
public Spliterator<E> spliterator ()
Creates a late-binding
and fail-fast Spliterator
over the elements in this set.
The Spliterator
reports Spliterator#SIZED
,
Spliterator#DISTINCT
, and ORDERED
. Implementations
should document the reporting of additional characteristic values.
Implementation Note:
- The implementation creates a
late-binding spliterator
from the set's
Iterator
. The spliterator inherits the
fail-fast properties of the set's iterator.
The created Spliterator
additionally reports
Spliterator#SUBSIZED
.
Returns |
Spliterator<E> |
a Spliterator over the elements in this set |