Spec-Zone.ru › OpenJDK 27

Интерфейс Set<E>

Параметры типа:
E — тип элементов, хранящихся в этом множестве
Все супер-интерфейсы:
Collection<E>, Iterable<E>
Все известные подинтерфейсы:
EventSet, NavigableSet<E>, SequencedSet<E>, SortedSet<E>
Все известные реализующие классы:
AbstractSet, ConcurrentHashMap.KeySetView, ConcurrentSkipListSet, CopyOnWriteArraySet, EnumSet, HashSet, JobStateReasons, LinkedHashSet, TreeSet
public interface Set<E> extends Collection<E>
Коллекция, не содержащая повторяющихся элементов. В более формальном смысле множества не содержат пары элементов e1 и e2, таких что e1.equals(e2), и содержат не более одного элемента null. Как следует из названия, этот интерфейс моделирует математическое понятие множества.

Интерфейс Set устанавливает дополнительные требования к контрактам всех конструкторов, а также к контрактам методов add, equals и hashCode, помимо унаследованных от интерфейса Collection. Для удобства здесь также приведены объявления других унаследованных методов. (Спецификации, сопровождающие эти объявления, адаптированы к интерфейсу Set, но не содержат дополнительных требований.)

Дополнительное требование к конструкторам, как и следовало ожидать, состоит в том, что все конструкторы должны создавать множество, не содержащее повторяющихся элементов (в соответствии с приведенным выше определением).

Примечание. При использовании изменяемых объектов в качестве элементов множества следует соблюдать особую осторожность. Поведение множества не определено, если значение объекта изменяется таким образом, который влияет на сравнения equals, пока объект является элементом множества. Частный случай этого запрета — множество не может содержать само себя в качестве элемента.

Некоторые реализации множеств накладывают ограничения на элементы, которые они могут содержать. Например, некоторые реализации запрещают элементы null, а другие ограничивают типы элементов. Попытка добавить недопустимый элемент приводит к непроверяемому исключению, обычно NullPointerException или ClassCastException. При попытке проверить наличие недопустимого элемента может быть выброшено исключение либо просто возвращено false; одни реализации ведут себя первым образом, другие — вторым. В более общем случае попытка выполнить операцию с недопустимым элементом, завершение которой не привело бы к добавлению недопустимого элемента в множество, может вызвать исключение или завершиться успешно — на усмотрение реализации. В спецификации этого интерфейса такие исключения помечены как «необязательные».

Неизменяемые множества

Статические фабричные методы Set.of и Set.copyOf предоставляют удобный способ создания неизменяемых множеств. Экземпляры Set, созданные этими методами, обладают следующими характеристиками:

  • Они неизменяемы. Добавлять или удалять элементы нельзя. Вызов любого метода-мутатора для Set всегда приводит к выбрасыванию UnsupportedOperationException. Однако, если содержащиеся элементы сами являются изменяемыми, это может привести к непоследовательному поведению Set или к тому, что его содержимое будет казаться изменившимся.
  • Они не допускают элементы null. Попытка создать их с элементами null приводит к NullPointerException.
  • Если не указано иное, они являются сериализуемыми, если все элементы сериализуемы.
  • При создании они отклоняют повторяющиеся элементы. Передача повторяющихся элементов статическому фабричному методу приводит к IllegalArgumentException.
  • Порядок перебора элементов множества не определен и может изменяться.
  • Они являются основанными на значениях. Программистам следует считать экземпляры, которые равны, взаимозаменяемыми и не использовать их для синхронизации, иначе возможно непредсказуемое поведение. Например, в будущей версии синхронизация может завершиться неудачно. Вызывающим кодам не следует делать предположений об идентичности возвращаемых экземпляров. Фабричные методы могут создавать новые экземпляры или повторно использовать существующие.
  • Они сериализуются в соответствии с описанием на странице Сериализованная форма.

Этот интерфейс является частью Java Collections Framework.

Начиная с:
1.2
См. также:
  • Collection
  • List
  • SortedSet
  • HashSet
  • TreeSet
  • AbstractSet
  • Collections.singleton(java.lang.Object)
  • Collections.EMPTY_SET

Краткое описание методов

Модификатор и тип Метод Описание
boolean add(E e)
Добавляет указанный элемент в это множество, если он еще не присутствует (необязательная операция).
boolean addAll(Collection<? extends E> c)
Добавляет все элементы указанной коллекции в это множество, если они еще не присутствуют (необязательная операция).
void clear()
Удаляет из этого множества все элементы (необязательная операция).
boolean contains(Object o)
Возвращает true, если это множество содержит указанный элемент.
boolean containsAll(Collection<?> c)
Возвращает true, если это множество содержит все элементы указанной коллекции.
static <E> Set<E> copyOf(Collection<? extends E> coll)
Возвращает неизменяемое множество, содержащее элементы указанной коллекции.
boolean equals(Object o)
Сравнивает указанный объект с этим множеством на равенство.
int hashCode()
Возвращает хеш-код этого множества.
boolean isEmpty()
Возвращает true, если это множество не содержит элементов.
Iterator<E> iterator()
Возвращает итератор по элементам этого множества.
static <E> Set<E> of()
Возвращает неизменяемое множество, содержащее ноль элементов.
static <E> Set<E> of(E e1)
Возвращает неизменяемое множество, содержащее один элемент.
static <E> Set<E> of(E... elements)
Возвращает неизменяемое множество, содержащее произвольное количество элементов.
static <E> Set<E> of(E e1, E e2)
Возвращает неизменяемое множество, содержащее два элемента.
static <E> Set<E> of(E e1, E e2, E e3)
Возвращает неизменяемое множество, содержащее три элемента.
static <E> Set<E> of(E e1, E e2, E e3, E e4)
Возвращает неизменяемое множество, содержащее четыре элемента.
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5)
Возвращает неизменяемое множество, содержащее пять элементов.
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6)
Возвращает неизменяемое множество, содержащее шесть элементов.
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)
Возвращает неизменяемое множество, содержащее семь элементов.
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)
Возвращает неизменяемое множество, содержащее восемь элементов.
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)
Возвращает неизменяемое множество, содержащее девять элементов.
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)
Возвращает неизменяемое множество, содержащее десять элементов.
static <E> Set<E> ofLazy(Set<? extends E> elementCandidates, Predicate<? super E> computingFunction)
Предварительная версия.
Возвращает новое множество с ленивыми вычислениями, логическое присутствие каждого отдельного кандидата в элементы из набора elementCandidates которого вычисляется по запросу с помощью предоставленного computingFunction.
boolean remove(Object o)
Удаляет указанный элемент из этого множества, если он присутствует (необязательная операция).
boolean removeAll(Collection<?> c)
Удаляет из этого множества все элементы, содержащиеся в указанной коллекции (необязательная операция).
boolean retainAll(Collection<?> c)
Оставляет в этом множестве только элементы, содержащиеся в указанной коллекции (необязательная операция).
int size()
Возвращает количество элементов в этом множестве (его мощность).
default Spliterator<E> spliterator()
Создает Spliterator по элементам этого множества.
Object[] toArray()
Возвращает массив, содержащий все элементы этого множества.
<T> T[] toArray(T[] a)
Возвращает массив, содержащий все элементы этого множества; тип возвращаемого массива во время выполнения совпадает с типом указанного массива.

Методы, объявленные в интерфейсе Collection

parallelStream, removeIf, stream, toArray
Модификатор и тип Метод Описание
default Stream<E> parallelStream()
Возвращает, возможно, параллельный Stream с этой коллекцией в качестве источника.
default boolean removeIf(Predicate<? super E> filter)
Удаляет из этой коллекции все элементы, удовлетворяющие заданному предикату (необязательная операция).
default Stream<E> stream()
Возвращает последовательный Stream с этой коллекцией в качестве источника.
default <T> T[] toArray(IntFunction<T[]> generator)
Возвращает массив, содержащий все элементы этой коллекции; для выделения возвращаемого массива используется предоставленная функция generator.

Методы, объявленные в интерфейсе Iterable

forEach
Модификатор и тип Метод Описание
default void forEach(Consumer<? super E> action)
Выполняет заданное действие для каждого элемента Iterable, пока не будут обработаны все элементы или пока действие не вызовет исключение.

Подробное описание методов

size

int size()
Возвращает количество элементов в этом множестве (его мощность). Если это множество содержит более Integer.MAX_VALUE элементов, возвращает Integer.MAX_VALUE.
Указано в:
size в интерфейсе Collection<E>
Возвращает:
количество элементов в этом множестве (его мощность)

isEmpty

boolean isEmpty()
Возвращает true, если это множество не содержит элементов.
Указано в:
isEmpty в интерфейсе Collection<E>
Возвращает:
true, если это множество не содержит элементов

contains

boolean contains(Object o)
Возвращает true, если это множество содержит указанный элемент. Точнее, возвращает true тогда и только тогда, когда это множество содержит элемент e такой, что Objects.equals(o, e).
Указано в:
contains в интерфейсе Collection<E>
Параметры:
o — элемент, наличие которого в этом множестве проверяется
Возвращает:
true, если это множество содержит указанный элемент
Вызывает:
ClassCastException — если тип указанного элемента несовместим с этим множеством (необязательно)
NullPointerException — если указанный элемент равен null, а это множество не допускает элементы null (необязательно)

iterator

Iterator<E> iterator()
Возвращает итератор по элементам этого множества. Элементы возвращаются в произвольном порядке (если только это множество не является экземпляром класса, который гарантирует определённый порядок).
Указано в:
iterator в интерфейсе Collection<E>
Указано в:
iterator в интерфейсе Iterable<E>
Возвращает:
итератор по элементам этого множества

toArray

Object[] toArray()
Возвращает массив, содержащий все элементы этого множества. Если это множество гарантирует определённый порядок возврата элементов итератором, этот метод должен возвращать элементы в том же порядке.

Возвращаемый массив будет «безопасным», поскольку это множество не хранит на него ссылок. (Другими словами, этот метод должен выделить новый массив, даже если это множество основано на массиве). Поэтому вызывающий код может свободно изменять возвращённый массив.

Этот метод служит связующим звеном между API на основе массивов и API на основе коллекций.

Указано в:
toArray в интерфейсе Collection<E>
Возвращает:
массив, содержащий все элементы этого множества

toArray

<T> T[] toArray(T[] a)
Возвращает массив, содержащий все элементы этого множества; тип возвращаемого массива во время выполнения совпадает с типом указанного массива. Если множество помещается в указанный массив, оно возвращается в нём. В противном случае выделяется новый массив с типом указанного массива во время выполнения и размером этого множества.

Если это множество помещается в указанный массив с запасом (то есть массив содержит больше элементов, чем это множество), элемент массива, следующий непосредственно за концом множества, устанавливается в null. (Это полезно для определения длины этого множества только в том случае, если вызывающий код знает, что множество не содержит элементов null.)

Если это множество гарантирует определённый порядок возврата элементов итератором, этот метод должен возвращать элементы в том же порядке.

Как и метод toArray(), этот метод служит связующим звеном между API на основе массивов и API на основе коллекций. Кроме того, этот метод позволяет точно контролировать тип выходного массива во время выполнения и при определённых обстоятельствах может помочь сократить затраты на выделение памяти.

Предположим, что x — это множество, которое, как известно, содержит только строки. Следующий код можно использовать для выгрузки множества в заново выделенный массив типа String:

    String[] y = x.toArray(new String[0]);
Обратите внимание, что toArray(new Object[0]) функционально идентичен toArray().
Указано в:
toArray в интерфейсе Collection<E>
Параметры типа:
T — тип компонента массива, в котором будет храниться коллекция
Параметры:
a — массив, в котором будут храниться элементы этого множества, если он достаточно велик; в противном случае для этой цели выделяется новый массив того же типа во время выполнения.
Возвращает:
массив, содержащий все элементы этого множества
Вызывает:
ArrayStoreException — если тип указанного массива во время выполнения не является супертипом типа во время выполнения каждого элемента этого множества
NullPointerException — если указанный массив равен null

add

boolean add(E e)
Добавляет указанный элемент в это множество, если он ещё не присутствует (необязательная операция). Точнее, добавляет указанный элемент e в это множество, если множество не содержит элемента e2 такого, что Objects.equals(e, e2). Если множество уже содержит этот элемент, вызов оставляет множество без изменений и возвращает false. В сочетании с ограничением на конструкторы это гарантирует, что множества никогда не содержат повторяющихся элементов.

Приведённое выше условие не означает, что множества обязаны принимать все элементы; множества могут отказаться добавлять любой конкретный элемент, включая null, и выбросить исключение, как описано в спецификации для Collection.add. Реализации множеств должны чётко документировать любые ограничения на содержащиеся в них элементы.

Указано в:
add в интерфейсе Collection<E>
Параметры:
e — элемент, который нужно добавить в это множество
Возвращает:
true, если это множество ещё не содержало указанный элемент
Вызывает:
UnsupportedOperationException — если операция add не поддерживается этим множеством
ClassCastException — если класс указанного элемента препятствует его добавлению в это множество
NullPointerException — если указанный элемент равен null, а это множество не допускает элементы null
IllegalArgumentException — если какое-либо свойство указанного элемента препятствует его добавлению в это множество

remove

boolean remove(Object o)
Удаляет указанный элемент из этого множества, если он присутствует (необязательная операция). Точнее, удаляет элемент e такой, что Objects.equals(o, e), если это множество содержит такой элемент. Возвращает true, если это множество содержало элемент (или, что эквивалентно, если множество изменилось в результате вызова). (После завершения вызова это множество не будет содержать этот элемент.)
Указано в:
remove в интерфейсе Collection<E>
Параметры:
o — объект, который нужно удалить из этого множества, если он присутствует
Возвращает:
true, если это множество содержало указанный элемент
Вызывает:
ClassCastException — если тип указанного элемента несовместим с этим множеством (необязательно)
NullPointerException — если указанный элемент равен null, а это множество не допускает элементы null (необязательно)
UnsupportedOperationException — если операция remove не поддерживается этим множеством

containsAll

boolean containsAll(Collection<?> c)
Возвращает true, если это множество содержит все элементы указанной коллекции. Если указанная коллекция также является множеством, этот метод возвращает true, если она является подмножеством этого множества.
Указано в:
containsAll в интерфейсе Collection<E>
Параметры:
c — коллекция, наличие элементов которой в этом множестве проверяется
Возвращает:
true, если это множество содержит все элементы указанной коллекции
Вызывает:
ClassCastException — если типы одного или нескольких элементов указанной коллекции несовместимы с этим множеством (необязательно)
NullPointerException — если указанная коллекция содержит один или несколько элементов null, а это множество не допускает элементы null (необязательно), либо если указанная коллекция равна null
См. также:
  • contains(Object)

addAll

boolean addAll(Collection<? extends E> c)
Добавляет все элементы указанной коллекции в это множество, если они ещё не присутствуют (необязательная операция). Если указанная коллекция также является множеством, операция addAll фактически изменяет это множество так, что его значение становится объединением двух множеств. Поведение этой операции не определено, если указанная коллекция изменяется во время выполнения операции.
Указано в:
addAll в интерфейсе Collection<E>
Параметры:
c — коллекция, содержащая элементы для добавления в это множество
Возвращает:
true, если это множество изменилось в результате вызова
Вызывает:
UnsupportedOperationException — если операция addAll не поддерживается этим множеством
ClassCastException — если класс элемента указанной коллекции препятствует его добавлению в это множество
NullPointerException — если указанная коллекция содержит один или несколько элементов null, а это множество не допускает элементы null, либо если указанная коллекция равна null
IllegalArgumentException — если какое-либо свойство элемента указанной коллекции препятствует его добавлению в это множество
См. также:
  • add(Object)

retainAll

boolean retainAll(Collection<?> c)
Оставляет в этом множестве только те элементы, которые содержатся в указанной коллекции (необязательная операция). Другими словами, удаляет из этого множества все элементы, не содержащиеся в указанной коллекции. Если указанная коллекция также является множеством, эта операция фактически изменяет это множество так, что его значение становится пересечением двух множеств.
Указано в:
retainAll в интерфейсе Collection<E>
Параметры:
c — коллекция, содержащая элементы, которые нужно оставить в этом множестве
Возвращает:
true, если это множество изменилось в результате вызова
Вызывает:
UnsupportedOperationException — если операция retainAll не поддерживается этим множеством
ClassCastException — если класс элемента этого множества несовместим с указанной коллекцией (необязательно)
NullPointerException — если это множество содержит элемент null, а указанная коллекция не допускает элементы null (необязательно), либо если указанная коллекция равна null
См. также:
  • remove(Object)

removeAll

boolean removeAll(Collection<?> c)
Удаляет из этого множества все элементы, содержащиеся в указанной коллекции (необязательная операция). Если указанная коллекция также является множеством, эта операция фактически изменяет это множество так, что его значение становится асимметрической разностью двух множеств.
Указано в:
removeAll в интерфейсе Collection<E>
Параметры:
c — коллекция, содержащая элементы для удаления из этого множества
Возвращает:
true, если это множество изменилось в результате вызова
Вызывает:
UnsupportedOperationException — если операция removeAll не поддерживается этим множеством
ClassCastException — если класс элемента этого множества несовместим с указанной коллекцией (необязательно)
NullPointerException — если это множество содержит элемент null, а указанная коллекция не допускает элементы null (необязательно), либо если указанная коллекция равна null
См. также:
  • remove(Object)
  • contains(Object)

clear

void clear()
Удаляет все элементы из этого множества (необязательная операция). После возврата этого вызова множество будет пустым.
Указано в:
clear в интерфейсе Collection<E>
Вызывает:
UnsupportedOperationException — если метод clear не поддерживается этим множеством

equals

boolean equals(Object o)
Сравнивает указанный объект с этим множеством на равенство. Возвращает true, если указанный объект также является множеством, оба множества имеют одинаковый размер, и каждый элемент указанного множества содержится в этом множестве (или, что эквивалентно, каждый элемент этого множества содержится в указанном множестве). Это определение гарантирует, что метод equals корректно работает для различных реализаций интерфейса множества.
Указано в:
equals в интерфейсе Collection<E>
Переопределяет:
equals в классе Object
Параметры:
o — объект, который сравнивается на равенство с этим множеством
Возвращает:
true, если указанный объект равен этому множеству
См. также:
  • Object.equals(Object)
  • equals(Object)
  • List.equals(Object)

hashCode

int hashCode()
Возвращает значение хеш-кода этого множества. Хеш-код множества определяется как сумма хеш-кодов элементов множества, причём хеш-код элемента null определяется как ноль. Это гарантирует, что s1.equals(s2) подразумевает s1.hashCode()==s2.hashCode() для любых двух множеств s1 и s2, как того требует общий контракт Object.hashCode().
Указано в:
hashCode в интерфейсе Collection<E>
Переопределяет:
hashCode в классе Object
Возвращает:
значение хеш-кода этого множества
См. также:
  • Object.equals(Object)
  • equals(Object)

spliterator

default Spliterator<E> spliterator()
Создаёт Spliterator для элементов этого множества.

Spliterator сообщает о характеристике Spliterator.DISTINCT. Реализации должны документировать наличие дополнительных значений характеристик.

Указано в:
spliterator в интерфейсе Collection<E>
Указано в:
spliterator в интерфейсе Iterable<E>
Требования к реализации:
Реализация по умолчанию создаёт сплитератор с отложенной привязкой на основе Iterator множества. Сплитератор наследует свойства итератора множества, связанные с обнаружением изменений.

Созданный Spliterator дополнительно сообщает о характеристике Spliterator.SIZED.

Примечание к реализации:
Созданный Spliterator дополнительно сообщает о характеристике Spliterator.SUBSIZED.
Возвращает:
Spliterator для элементов этого множества
Начиная с:
1.8

of

static <E> Set<E> of()
Возвращает неизменяемое множество, содержащее ноль элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Возвращает:
пустое Set
Начиная с:
9

of

static <E> Set<E> of(E e1)
Возвращает неизменяемое множество, содержащее один элемент. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — единственный элемент
Возвращает:
Set, содержащее указанный элемент
Вызывает:
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2)
Возвращает неизменяемое множество, содержащее два элемента. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если элементы являются дубликатами
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3)
Возвращает неизменяемое множество, содержащее три элемента. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3, E e4)
Возвращает неизменяемое множество, содержащее четыре элемента. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5)
Возвращает неизменяемое множество, содержащее пять элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
e5 — пятый элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6)
Возвращает неизменяемое множество, содержащее шесть элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
e5 — пятый элемент
e6 — шестой элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)
Возвращает неизменяемое множество, содержащее семь элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
e5 — пятый элемент
e6 — шестой элемент
e7 — седьмой элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)
Возвращает неизменяемое множество, содержащее восемь элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
e5 — пятый элемент
e6 — шестой элемент
e7 — седьмой элемент
e8 — восьмой элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)
Возвращает неизменяемое множество, содержащее девять элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элемента Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
e5 — пятый элемент
e6 — шестой элемент
e7 — седьмой элемент
e8 — восьмой элемент
e9 — девятый элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент равен null
Начиная с:
9

of

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)
Возвращает неизменяемое множество, содержащее десять элементов. Подробности см. в разделе Неизменяемые множества.
Параметры типа:
E — тип элементов Set
Параметры:
e1 — первый элемент
e2 — второй элемент
e3 — третий элемент
e4 — четвёртый элемент
e5 — пятый элемент
e6 — шестой элемент
e7 — седьмой элемент
e8 — восьмой элемент
e9 — девятый элемент
e10 — десятый элемент
Возвращает:
Set, содержащее указанные элементы
Вызывает исключение:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент null
Начиная с:
9

of

@SafeVarargs static <E> Set<E> of(E... elements)
Возвращает неизменяемое множество, содержащее произвольное количество элементов. Подробности см. в разделе Неизменяемые множества.
Примечание API:
Этот метод также принимает в качестве аргумента один массив. Тип элементов результирующего множества будет соответствовать типу компонентов массива, а размер множества будет равен длине массива. Чтобы создать множество с единственным элементом, которым является массив, выполните следующее:
    String[] array = ... ;
    Set<String[]> list = Set.<String[]>of(array);
В этом случае будет вызван метод Set.of(E).
Параметры типа:
E — тип элементов Set
Параметры:
elements — элементы, которые будут содержаться в множестве
Возвращает:
Set, содержащее указанные элементы
Вызывает исключение:
IllegalArgumentException — если имеются повторяющиеся элементы
NullPointerException — если элемент null или массив null
Начиная с:
9

copyOf

static <E> Set<E> copyOf(Collection<? extends E> coll)
Возвращает неизменяемое множество, содержащее элементы указанной коллекции. Указанная коллекция не должна быть null и не должна содержать элементы null. Если указанная коллекция содержит повторяющиеся элементы, сохраняется произвольный элемент из каждой группы повторов. Если указанная коллекция впоследствии изменится, возвращённое множество не будет отражать эти изменения.
Примечание по реализации:
Если указанная коллекция является неизменяемым множеством, вызов copyOf обычно не создаёт копию.
Параметры типа:
E — тип элементов Set
Параметры:
coll — Collection, из которой берутся элементы; не должна быть null
Возвращает:
Set, содержащее элементы указанной Collection
Вызывает исключение:
NullPointerException — если coll равно null или содержит значения null
Начиная с:
10

ofLazy

static <E> Set<E> ofLazy(Set<? extends E> elementCandidates, Predicate<? super E> computingFunction)
ofLazy — предварительная версия API платформы Java.
Программы могут использовать ofLazy только при включённых функциях предварительной версии.
Функции предварительной версии могут быть удалены в будущем выпуске или стать постоянными функциями платформы Java.
Возвращает новое множество с ленивыми вычислениями, логическая принадлежность каждого отдельного кандидата на элемент в наборе elementCandidates которого вычисляется по запросу с помощью предоставленного computingFunction.

Далее термин статус принадлежности используется для обозначения того, принадлежит ли элемент возвращённому множеству. То есть, если статус принадлежности элемента E равен true, то E является элементом возвращённого множества. И наоборот, если статус принадлежности элемента E равен false, то E не является элементом возвращённого множества.

Возвращённое множество является неизменяемым. Элементы возвращённого множества формируются из кандидатов на элементы, заданных при создании, с учётом вычисления статуса принадлежности каждого элемента. Статусы принадлежности элементов множества вычисляются лениво с помощью предоставленного computingFunction при первом обращении (например, через Set::contains). После успешного вычисления статуса принадлежности кандидата на элемент соответствующий статус инициализируется (то есть устанавливается как логическая принадлежность или логическое отсутствие принадлежности).

Гарантируется, что предоставленная вычисляющая функция будет вызвана не более одного раза для каждого кандидата на элемент, даже в многопоточной среде. Потоки, обращающиеся к кандидату на элемент, статус принадлежности которого уже вычисляется, будут заблокированы до тех пор, пока статус принадлежности кандидата не будет вычислен или вычисляющая функция не завершится с ошибкой.

Если при вычислении предоставленной вычисляющей функцией возникает непроверяемое исключение (для кандидата на элемент), ленивый статус принадлежности не инициализируется, а переходит в состояние ошибки, после чего выбрасывается NoSuchElementException, причиной которого является непроверяемое исключение. При последующих вызовах Set::contains для того же кандидата на принадлежность выбрасывается NoSuchElementException (без повторного вызова вычисляющей функции), у которого нет причины и сообщение содержит имя класса исходного непроверяемого исключения.

Все сбои обрабатываются таким образом. Существует особый случай, при котором выбрасываются непроверяемые исключения:

Если вычисляющая функция рекурсивно вызывает себя (для того же кандидата на принадлежность) через возвращённое ленивое множество, выбрасывается NoSuchElementException (причиной которого является IllegalStateException).

Методы Object возвращённого множества — equals(), hashCode() и toString() — могут инициировать инициализацию одного или нескольких ленивых элементов. Если инициализация хотя бы одного элемента завершается с ошибкой, методы hashCode() и toString() выбрасывают NoSuchElementException, а метод Object.equals(Object) выбрасывает NoSuchElementException при попытке сравнить элемент, который не удалось вычислить.

Возвращённое ленивое множество хранит сильную ссылку на лежащую в его основе вычисляющую функцию, используемую для вычисления статуса принадлежности, по крайней мере до тех пор, пока остаются невычисленные кандидаты на элементы.

Возвращённое множество не является сериализуемым.

Если предоставленный Set elementCandidates впоследствии изменится, возвращённое Set не будет отражать эти изменения.

Set elementCandidates должно использовать equals() в качестве отношения эквивалентности либо его метод сравнения должен быть согласован с equals(); в противном случае поведение не специфицировано.

Рассмотрим пример приложения, которое управляет различными настраиваемыми параметрами, часто называемыми «переключателями», определяющими его поведение. Состояние этих переключателей можно определить через командную строку, файл конфигурации или даже подключение к базе данных. Используя ленивое множество, мы гарантируем, что состояния этих переключателей будут вычислены только один раз. После вычисления результаты могут подвергаться свёртке констант JVM:

class Application {

    enum Option {VERBOSE, DRY_RUN, STRICT}

    // Lazily initialized Set of Options
    static final Set<Option> OPTIONS =
            Set.ofLazy(EnumSet.allOf(Option.class), Application::isEnabled);

    // Return true when the given Option is enabled
    private static boolean isEnabled(Option option) {
        // Parse command line, read configuration file, load database
        ...
    }

    public static void process() {
        // The if condition (and subsequent eliminated branch) is
        // eligible for constant folding (and code elimination).
        if (OPTIONS.contains(Option.DRY_RUN)) {
            // Skip processing in DRY_RUN mode
            return;
        }
        // Actual processing logic
    }

}

Возвращённое Set<E> можно представить как множество, основанное на поле Map<E, LazyConstant<Boolean>>, где операция contains(Object) эквивалентна следующему:

 class LazySet<E> extends AbstractCollection<E> implements Set<E> {

     private final Map<E, LazyConstant<Boolean>> backingMap;

     public LazySet(Set<E> elementCandidates, Predicate<E> computingFunction) {
         this.backingMap = elementCandidates.stream()
                 .collect(Collectors.toUnmodifiableMap(
                         Function.identity(),
                         k -> LazyConstant.of(() -> computingFunction.test(k))));
     }

     @Override
     public boolean contains(Object o) {
         var lazyConstant = backingMap.get(o);
         return lazyConstant == null
                 ? false
                 : lazyConstant.get();
     }
 }
Однако производительность и эффективность использования памяти могут быть выше.

Элементы возвращённого множества могут подвергаться определённым оптимизациям производительности, например свёртке констант, описанной в LazyConstant.

Примечание по реализации:
после успешной инициализации статусов принадлежности всех элементов или перехода этих статусов в состояние ошибки сильная ссылка на вычисляющую функцию больше не хранится, и она становится доступной для сборки мусора.
Параметры типа:
E — тип элементов, хранящихся в возвращённом множестве
Параметры:
elementCandidates — кандидаты на элементы, подлежащие оценке (не должны быть null)
computingFunction — вызывается при первом вычислении статуса принадлежности кандидата на элемент
Возвращает:
новое множество с ленивыми вычислениями, логическая принадлежность каждого отдельного кандидата на элемент в наборе elementCandidates которого вычисляется по запросу с помощью предоставленного computingFunction
Вызывает исключение:
NullPointerException — если предоставленное множество elementCandidates равно null, если множество elementCandidates содержит элемент null или если предоставленный computingFunction равен null
Начиная с:
27
См. также:
  • LazyConstantПРЕДВАРИТЕЛЬНАЯ ВЕРСИЯ

Сообщить об ошибке или предложить улучшение
Дополнительные справочные материалы по API и документацию для разработчиков см. в документации Java SE, содержащей более подробные описания для разработчиков, обзоры концепций, определения терминов, обходные решения и примеры работающего кода. Другие версии.
Java является товарным знаком или зарегистрированным товарным знаком Oracle и/или её аффилированных лиц в США и других странах.
Авторские права © 1993, 2026, Oracle и/или её аффилированные лица, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
Все права защищены. Использование регулируется условиями лицензии и политикой распространения документации.

© 1993, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API