@GwtCompatible(serializable=true, emulated=true) public abstract class ImmutableSet<E> extends ImmutableCollection<E> implements Set<E>
Set
whose contents will never change, with many other important properties detailed at
ImmutableCollection
.Modifier and Type | Class and Description |
---|---|
static class |
ImmutableSet.Builder<E>
A builder for creating
ImmutableSet instances. |
Modifier and Type | Method and Description |
---|---|
ImmutableList<E> |
asList()
Returns an
ImmutableList containing the same elements, in the same order, as this
collection. |
static <E> ImmutableSet.Builder<E> |
builder()
Returns a new builder.
|
static <E> ImmutableSet.Builder<E> |
builderWithExpectedSize(int expectedSize)
Returns a new builder, expecting the specified number of distinct elements to be added.
|
static <E> ImmutableSet<E> |
copyOf(Collection<? extends E> elements)
Returns an immutable set containing each of
elements , minus duplicates, in the order
each appears first in the source collection. |
static <E> ImmutableSet<E> |
copyOf(E[] elements)
Returns an immutable set containing each of
elements , minus duplicates, in the order
each appears first in the source array. |
static <E> ImmutableSet<E> |
copyOf(Iterable<? extends E> elements)
Returns an immutable set containing each of
elements , minus duplicates, in the order
each appears first in the source iterable. |
static <E> ImmutableSet<E> |
copyOf(Iterator<? extends E> elements)
Returns an immutable set containing each of
elements , minus duplicates, in the order
each appears first in the source iterator. |
boolean |
equals(@Nullable Object object)
Indicates whether some other object is "equal to" this one.
|
int |
hashCode()
Returns a hash code value for the object.
|
abstract UnmodifiableIterator<E> |
iterator()
Returns an unmodifiable iterator across the elements in this collection.
|
static <E> ImmutableSet<E> |
of()
Returns the empty immutable set.
|
static <E> ImmutableSet<E> |
of(E element)
Returns an immutable set containing
element . |
static <E> ImmutableSet<E> |
of(E e1,
E e2)
Returns an immutable set containing the given elements, minus duplicates, in the order each was
first specified.
|
static <E> ImmutableSet<E> |
of(E e1,
E e2,
E e3)
Returns an immutable set containing the given elements, minus duplicates, in the order each was
first specified.
|
static <E> ImmutableSet<E> |
of(E e1,
E e2,
E e3,
E e4)
Returns an immutable set containing the given elements, minus duplicates, in the order each was
first specified.
|
static <E> ImmutableSet<E> |
of(E e1,
E e2,
E e3,
E e4,
E e5)
Returns an immutable set containing the given elements, minus duplicates, in the order each was
first specified.
|
static <E> ImmutableSet<E> |
of(E e1,
E e2,
E e3,
E e4,
E e5,
E e6,
E... others)
Returns an immutable set containing the given elements, minus duplicates, in the order each was
first specified.
|
static <E> Collector<E,?,ImmutableSet<E>> |
toImmutableSet()
Returns a
Collector that accumulates the input elements into a new ImmutableSet . |
add, addAll, clear, contains, remove, removeAll, removeIf, retainAll, spliterator, toArray, toArray
containsAll, isEmpty, size, toString
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
add, addAll, clear, contains, containsAll, isEmpty, remove, removeAll, retainAll, size, spliterator, toArray, toArray
parallelStream, removeIf, stream
public static <E> Collector<E,?,ImmutableSet<E>> toImmutableSet()
Collector
that accumulates the input elements into a new ImmutableSet
. Elements appear in the resulting set in the encounter order of the stream; if
the stream contains duplicates (according to Object.equals(Object)
), only the first
duplicate in encounter order will appear in the result.public static <E> ImmutableSet<E> of()
Collections.emptySet()
for code
consistency, and because the return type conveys the immutability guarantee.public static <E> ImmutableSet<E> of(E element)
element
. Preferred over Collections.singleton(T)
for code consistency, null
rejection, and because the return
type conveys the immutability guarantee.public static <E> ImmutableSet<E> of(E e1, E e2)
public static <E> ImmutableSet<E> of(E e1, E e2, E e3)
public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4)
public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4, E e5)
@SafeVarargs public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E... others)
The array others
must not be longer than Integer.MAX_VALUE - 6
.
public static <E> ImmutableSet<E> copyOf(Collection<? extends E> elements)
elements
, minus duplicates, in the order
each appears first in the source collection.
Performance note: This method will sometimes recognize that the actual copy operation
is unnecessary; for example, copyOf(copyOf(anArrayList))
will copy the data only once.
This reduces the expense of habitually making defensive copies at API boundaries. However, the
precise conditions for skipping the copy operation are undefined.
NullPointerException
- if any of elements
is nullpublic static <E> ImmutableSet<E> copyOf(Iterable<? extends E> elements)
elements
, minus duplicates, in the order
each appears first in the source iterable. This method iterates over elements
only
once.
Performance note: This method will sometimes recognize that the actual copy operation
is unnecessary; for example, copyOf(copyOf(anArrayList))
should copy the data only
once. This reduces the expense of habitually making defensive copies at API boundaries.
However, the precise conditions for skipping the copy operation are undefined.
NullPointerException
- if any of elements
is nullpublic static <E> ImmutableSet<E> copyOf(Iterator<? extends E> elements)
elements
, minus duplicates, in the order
each appears first in the source iterator.NullPointerException
- if any of elements
is nullpublic static <E> ImmutableSet<E> copyOf(E[] elements)
elements
, minus duplicates, in the order
each appears first in the source array.NullPointerException
- if any of elements
is nullpublic boolean equals(@Nullable Object object)
java.lang.Object
The equals
method implements an equivalence relation
on non-null object references:
x
, x.equals(x)
should return
true
.
x
and y
, x.equals(y)
should return true
if and only if
y.equals(x)
returns true
.
x
, y
, and z
, if
x.equals(y)
returns true
and
y.equals(z)
returns true
, then
x.equals(z)
should return true
.
x
and y
, multiple invocations of
x.equals(y)
consistently return true
or consistently return false
, provided no
information used in equals
comparisons on the
objects is modified.
x
,
x.equals(null)
should return false
.
The equals
method for class Object
implements
the most discriminating possible equivalence relation on objects;
that is, for any non-null reference values x
and
y
, this method returns true
if and only
if x
and y
refer to the same object
(x == y
has the value true
).
Note that it is generally necessary to override the hashCode
method whenever this method is overridden, so as to maintain the
general contract for the hashCode
method, which states
that equal objects must have equal hash codes.
equals
in interface Collection<E>
equals
in interface Set<E>
equals
in class Object
object
- the reference object with which to compare.true
if this object is the same as the obj
argument; false
otherwise.Object.hashCode()
,
HashMap
public int hashCode()
java.lang.Object
HashMap
.
The general contract of hashCode
is:
hashCode
method
must consistently return the same integer, provided no information
used in equals
comparisons on the object is modified.
This integer need not remain consistent from one execution of an
application to another execution of the same application.
equals(Object)
method, then calling the hashCode
method on each of
the two objects must produce the same integer result.
Object.equals(java.lang.Object)
method, then calling the hashCode
method on each of the
two objects must produce distinct integer results. However, the
programmer should be aware that producing distinct integer results
for unequal objects may improve the performance of hash tables.
As much as is reasonably practical, the hashCode method defined by
class Object
does return distinct integers for distinct
objects. (This is typically implemented by converting the internal
address of the object into an integer, but this implementation
technique is not required by the
Java™ programming language.)
hashCode
in interface Collection<E>
hashCode
in interface Set<E>
hashCode
in class Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public abstract UnmodifiableIterator<E> iterator()
ImmutableCollection
public ImmutableList<E> asList()
ImmutableCollection
ImmutableList
containing the same elements, in the same order, as this
collection.
Performance note: in most cases this method can return quickly without actually copying anything. The exact circumstances under which the copy is performed are undefined and subject to change.
asList
in class ImmutableCollection<E>
public static <E> ImmutableSet.Builder<E> builder()
ImmutableSet.Builder
constructor.@Beta public static <E> ImmutableSet.Builder<E> builderWithExpectedSize(int expectedSize)
If expectedSize
is exactly the number of distinct elements added to the builder
before ImmutableSet.Builder.build()
is called, the builder is likely to perform better than an unsized
builder()
would have.
It is not specified if any performance benefits apply if expectedSize
is close to,
but not exactly, the number of distinct elements added to the builder.
Copyright © 2010–2019. All rights reserved.