Spec-Zone.ru › OpenJDK 27

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

Параметры типа:
E - тип элементов в этом списке
Все суперинтерфейсы:
Collection<E>, Iterable<E>, SequencedCollection<E>
Все известные реализующие классы:
AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector
public interface List<E> extends SequencedCollection<E>
Упорядоченная коллекция, в которой пользователь точно контролирует, в какое место списка вставляется каждый элемент. Пользователь может обращаться к элементам по целочисленному индексу (позиции в списке) и выполнять поиск элементов в списке.

В отличие от множеств, списки обычно допускают дублирующиеся элементы. Строго говоря, списки обычно допускают пары элементов e1 и e2 такие, что e1.equals(e2), а также обычно допускают несколько элементов null, если вообще допускают элементы null. Вполне возможно, что кому-то может понадобиться реализовать список, запрещающий дубликаты, выбрасывая исключения времени выполнения при попытке пользователя вставить их, но мы ожидаем, что такой сценарий использования будет редким.

Интерфейс List устанавливает дополнительные требования к контрактам методов iterator, add, remove, equals и hashCode, помимо указанных в интерфейсе Collection. Объявления других унаследованных методов также приведены здесь для удобства.

Интерфейс List предоставляет четыре метода для позиционного (индексированного) доступа к элементам списка. Индексация списков, как и массивов Java, начинается с нуля. Обратите внимание, что для некоторых реализаций время выполнения этих операций может быть пропорционально значению индекса (например, для класса LinkedList). Поэтому, если вызывающему коду неизвестна реализация, обычно предпочтительнее перебирать элементы списка, а не обращаться к ним по индексам.

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

Интерфейс List предоставляет два метода для поиска указанного объекта. С точки зрения производительности эти методы следует использовать с осторожностью. Во многих реализациях они выполняют затратный линейный поиск.

Интерфейс List предоставляет два метода для эффективной вставки и удаления нескольких элементов в произвольной позиции списка.

Примечание. Хотя списки могут содержать сами себя в качестве элементов, рекомендуется проявлять крайнюю осторожность: методы equals и hashCode для такого списка больше не имеют четко определенного поведения.

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

Неизменяемые списки

Статические фабричные методы List.of, List.copyOf и ofLazy(int, IntFunction)ПРЕДВАРИТЕЛЬНАЯ ВЕРСИЯ предоставляют удобный способ создания неизменяемых списков. Экземпляры List, созданные этими методами, обладают следующими характеристиками:

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

Этот интерфейс входит в состав Java Collections Framework.

Начиная с версии:
1.2
См. также:
  • Collection
  • Set
  • ArrayList
  • LinkedList
  • Vector
  • Arrays.asList(Object[])
  • Collections.nCopies(int, Object)
  • Collections.EMPTY_LIST
  • AbstractList
  • AbstractSequentialList

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

Модификатор и тип Метод Описание
void add(int index, E element)
Вставляет указанный элемент в заданную позицию этого списка (необязательная операция).
boolean add(E e)
Добавляет указанный элемент в конец этого списка (необязательная операция).
boolean addAll(int index, Collection<? extends E> c)
Вставляет все элементы указанной коллекции в этот список, начиная с заданной позиции (необязательная операция).
boolean addAll(Collection<? extends E> c)
Добавляет все элементы указанной коллекции в конец этого списка в порядке, в котором их возвращает итератор указанной коллекции (необязательная операция).
default void addFirst(E e)
Добавляет элемент в начало этой коллекции (необязательная операция).
default void addLast(E e)
Добавляет элемент в конец этой коллекции (необязательная операция).
void clear()
Удаляет все элементы из этого списка (необязательная операция).
boolean contains(Object o)
Возвращает true, если этот список содержит указанный элемент.
boolean containsAll(Collection<?> c)
Возвращает true, если этот список содержит все элементы указанной коллекции.
static <E> List<E> copyOf(Collection<? extends E> coll)
Возвращает неизменяемый List, содержащий элементы заданной Collection в порядке их перебора.
boolean equals(Object o)
Сравнивает указанный объект с этим списком на равенство.
E get(int index)
Возвращает элемент, находящийся в указанной позиции этого списка.
default E getFirst()
Получает первый элемент этой коллекции.
default E getLast()
Получает последний элемент этой коллекции.
int hashCode()
Возвращает значение хеш-кода этого списка.
int indexOf(Object o)
Возвращает индекс первого вхождения указанного элемента в этом списке или -1, если список не содержит этот элемент.
boolean isEmpty()
Возвращает true, если этот список не содержит элементов.
Iterator<E> iterator()
Возвращает итератор для перебора элементов этого списка в надлежащем порядке.
int lastIndexOf(Object o)
Возвращает индекс последнего вхождения указанного элемента в этом списке или -1, если список не содержит этот элемент.
ListIterator<E> listIterator()
Возвращает итератор списка для перебора элементов этого списка (в надлежащем порядке).
ListIterator<E> listIterator(int index)
Возвращает итератор списка для перебора элементов этого списка (в надлежащем порядке), начиная с указанной позиции.
static <E> List<E> of()
Возвращает неизменяемый список, не содержащий элементов.
static <E> List<E> of(E e1)
Возвращает неизменяемый список, содержащий один элемент.
static <E> List<E> of(E... elements)
Возвращает неизменяемый список, содержащий произвольное количество элементов.
static <E> List<E> of(E e1, E e2)
Возвращает неизменяемый список, содержащий два элемента.
static <E> List<E> of(E e1, E e2, E e3)
Возвращает неизменяемый список, содержащий три элемента.
static <E> List<E> of(E e1, E e2, E e3, E e4)
Возвращает неизменяемый список, содержащий четыре элемента.
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5)
Возвращает неизменяемый список, содержащий пять элементов.
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6)
Возвращает неизменяемый список, содержащий шесть элементов.
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)
Возвращает неизменяемый список, содержащий семь элементов.
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)
Возвращает неизменяемый список, содержащий восемь элементов.
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)
Возвращает неизменяемый список, содержащий девять элементов.
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
Возвращает неизменяемый список, содержащий десять элементов.
static <E> List<E> ofLazy(int size, IntFunction<? extends E> computingFunction)
Предварительная версия.
Возвращает новый лениво вычисляемый список из предоставленных size.
E remove(int index)
Удаляет элемент, находящийся в указанной позиции этого списка (необязательная операция).
boolean remove(Object o)
Удаляет первое вхождение указанного элемента из этого списка, если оно присутствует (необязательная операция).
boolean removeAll(Collection<?> c)
Удаляет из этого списка все элементы, содержащиеся в указанной коллекции (необязательная операция).
default E removeFirst()
Удаляет и возвращает первый элемент этой коллекции (необязательная операция).
default E removeLast()
Удаляет и возвращает последний элемент этой коллекции (необязательная операция).
default void replaceAll(UnaryOperator<E> operator)
Заменяет каждый элемент этого списка результатом применения оператора к этому элементу (необязательная операция).
boolean retainAll(Collection<?> c)
Оставляет в этом списке только элементы, содержащиеся в указанной коллекции (необязательная операция).
default List<E> reversed()
Возвращает представление этой коллекции в обратном порядке.
E set(int index, E element)
Заменяет элемент, находящийся в указанной позиции этого списка, указанным элементом (необязательная операция).
int size()
Возвращает количество элементов в этом списке.
default void sort(Comparator<? super E> c)
Сортирует этот список в соответствии с порядком, задаваемым указанным Comparator (необязательная операция).
default Spliterator<E> spliterator()
Создает Spliterator для перебора элементов этого списка.
List<E> subList(int fromIndex, int toIndex)
Возвращает представление части этого списка между fromIndex (включительно) и toIndex (не включая).
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>
Возвращает:
массив, содержащий все элементы этого списка в надлежащем порядке
См. также:
  • Arrays.asList(Object[])

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)
Добавляет указанный элемент в конец этого списка (необязательная операция).

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

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

remove

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

containsAll

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

addAll

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

addAll

boolean addAll(int index, Collection<? extends E> c)
Вставляет все элементы указанной коллекции в этот список с указанной позиции (необязательная операция). Сдвигает элемент, находящийся сейчас на этой позиции (если он есть), и все последующие элементы вправо (увеличивая их индексы). Новые элементы появятся в этом списке в том порядке, в котором их возвращает итератор указанной коллекции. Поведение этой операции не определено, если указанная коллекция изменяется во время её выполнения. (Это произойдёт, если указанная коллекция — сам этот список и он не пуст.)
Параметры:
index - индекс, по которому следует вставить первый элемент указанной коллекции
c - коллекция, содержащая элементы, которые нужно добавить в этот список
Возвращает:
true, если в результате вызова этот список изменился
Выбрасывает:
UnsupportedOperationException - если этот список не поддерживает операцию addAll
ClassCastException - если класс элемента указанной коллекции не позволяет добавить его в этот список
NullPointerException - если указанная коллекция содержит один или несколько элементов null, а этот список не допускает элементы null, или если указанная коллекция равна null
IllegalArgumentException - если какое-либо свойство элемента указанной коллекции не позволяет добавить его в этот список
IndexOutOfBoundsException - если индекс выходит за допустимый диапазон (index < 0 || index > size())

removeAll

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

retainAll

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

replaceAll

default void replaceAll(UnaryOperator<E> operator)
Заменяет каждый элемент этого списка результатом применения оператора к этому элементу (необязательная операция). Ошибки и исключения времени выполнения, выброшенные оператором, передаются вызывающему коду.
Требования к реализации:
Реализация по умолчанию эквивалентна следующему для этого list:
    final ListIterator<E> li = list.listIterator();
    while (li.hasNext()) {
        li.set(operator.apply(li.next()));
    }
Если итератор списка не поддерживает операцию set, при замене первого элемента будет выброшено UnsupportedOperationException.
Параметры:
operator - оператор, применяемый к каждому элементу
Выбрасывает:
UnsupportedOperationException - если этот список не поддерживает операцию replaceAll
NullPointerException - если указанный оператор равен null или если результат оператора равен null, а этот список не допускает элементы null (необязательно)
Начиная с версии:
1.8

sort

default void sort(Comparator<? super E> c)
Сортирует этот список в соответствии с порядком, задаваемым указанным Comparator (необязательная операция). Сортировка является стабильной: этот метод не должен менять порядок равных элементов.

Все элементы этого списка должны быть взаимно сравнимыми с помощью указанного компаратора (то есть c.compare(e1, e2) не должен выбрасывать ClassCastException для каких-либо элементов e1 и e2 в списке).

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

Этот список должен допускать изменение, но не обязательно изменение размера.

Требования к реализации:
Реализация по умолчанию получает массив, содержащий все элементы этого списка, сортирует массив и проходит по списку, присваивая каждому элементу значение из соответствующей позиции массива. (Это позволяет избежать производительности n2 log(n), которая была бы достигнута при попытке сортировать связанный список на месте.)
Примечание по реализации:
Эта реализация представляет собой стабильную, адаптивную, итеративную сортировку слиянием, которая при частично отсортированном входном массиве требует значительно меньше сравнений, чем n lg(n), обеспечивая при этом производительность традиционной сортировки слиянием для случайно упорядоченного массива. Если входной массив почти отсортирован, реализации требуется приблизительно n сравнений. Требования к временной памяти варьируются от небольшой константы для почти отсортированных входных массивов до n/2 ссылок на объекты для случайно упорядоченных входных массивов.

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

Реализация адаптирована из алгоритма сортировки списков Тима Питерса для Python ( TimSort). В ней используются методы из работы Питера Мак-Илроя «Optimistic Sorting and Information Theoretic Complexity», опубликованной в трудах четвёртого ежегодного симпозиума ACM-SIAM по дискретным алгоритмам, стр. 467–474, январь 1993 г.

Параметры:
c - Comparator, используемый для сравнения элементов списка. Значение null указывает на то, что следует использовать естественный порядок элементов
Выбрасывает:
ClassCastException - если список содержит элементы, которые не являются взаимно сравнимыми с помощью указанного компаратора
UnsupportedOperationException - если этот список не поддерживает операцию sort
IllegalArgumentException - (необязательно) если обнаружено, что компаратор нарушает контракт Comparator
Начиная с версии:
1.8

clear

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

equals

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

hashCode

int hashCode()
Возвращает значение хеш-кода этого списка. Хеш-код списка определяется результатом следующего вычисления:
    int hashCode = 1;
    for (E e : list)
        hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
Это гарантирует, что из list1.equals(list2) следует list1.hashCode()==list2.hashCode() для любых двух списков list1 и list2, как того требует общий контракт Object.hashCode().
Определён в:
hashCode в интерфейсе Collection<E>
Переопределяет:
hashCode в классе Object
Возвращает:
значение хеш-кода этого списка
См. также:
  • Object.equals(Object)
  • equals(Object)

get

E get(int index)
Возвращает элемент, находящийся в указанной позиции этого списка.
Параметры:
index - индекс возвращаемого элемента
Возвращает:
элемент, находящийся в указанной позиции этого списка
Выбрасывает:
IndexOutOfBoundsException - если индекс выходит за допустимый диапазон (index < 0 || index >= size())

set

E set(int index, E element)
Заменяет элемент, находящийся в указанной позиции этого списка, указанным элементом (необязательная операция).
Параметры:
index - индекс заменяемого элемента
element - элемент, который нужно сохранить в указанной позиции
Возвращает:
элемент, ранее находившийся в указанной позиции
Выбрасывает:
UnsupportedOperationException - если этот список не поддерживает операцию set
ClassCastException - если класс указанного элемента не позволяет добавить его в этот список
NullPointerException - если указанный элемент равен null, а этот список не допускает элементы null
IllegalArgumentException - если какое-либо свойство указанного элемента не позволяет добавить его в этот список
IndexOutOfBoundsException - если индекс выходит за допустимый диапазон (index < 0 || index >= size())

add

void add(int index, E element)
Вставляет указанный элемент в указанную позицию этого списка (необязательная операция). Сдвигает элемент, находящийся сейчас на этой позиции (если он есть), и все последующие элементы вправо (увеличивая их индексы на единицу).
Параметры:
index - индекс, по которому следует вставить указанный элемент
element - вставляемый элемент
Выбрасывает:
UnsupportedOperationException - если этот список не поддерживает операцию add
ClassCastException - если класс указанного элемента не позволяет добавить его в этот список
NullPointerException - если указанный элемент равен null, а этот список не допускает элементы null
IllegalArgumentException - если какое-либо свойство указанного элемента не позволяет добавить его в этот список
IndexOutOfBoundsException - если индекс выходит за допустимый диапазон (index < 0 || index > size())

remove

E remove(int index)
Удаляет элемент, находящийся в указанной позиции этого списка (необязательная операция). Сдвигает все последующие элементы влево (уменьшая их индексы на единицу). Возвращает элемент, удалённый из списка.
Параметры:
index - индекс удаляемого элемента
Возвращает:
элемент, ранее находившийся в указанной позиции
Выбрасывает:
UnsupportedOperationException - если этот список не поддерживает операцию remove
IndexOutOfBoundsException - если индекс выходит за допустимый диапазон (index < 0 || index >= size())

indexOf

int indexOf(Object o)
Возвращает индекс первого вхождения указанного элемента в этом списке или -1, если список не содержит этот элемент. Формально, возвращает наименьший индекс i такой, что Objects.equals(o, get(i)), или -1, если такого индекса нет.
Параметры:
o - искомый элемент
Возвращает:
индекс первого вхождения указанного элемента в этом списке или -1, если список не содержит этот элемент
Выбрасывает:
ClassCastException - если тип указанного элемента несовместим с этим списком (необязательно)
NullPointerException - если указанный элемент равен null, а этот список не допускает элементы null (необязательно)

lastIndexOf

int lastIndexOf(Object o)
Возвращает индекс последнего вхождения указанного элемента в этом списке или -1, если список не содержит этот элемент. Формально, возвращает наибольший индекс i такой, что Objects.equals(o, get(i)), или -1, если такого индекса нет.
Параметры:
o - искомый элемент
Возвращает:
индекс последнего вхождения указанного элемента в этом списке или -1, если список не содержит этот элемент
Выбрасывает:
ClassCastException - если тип указанного элемента несовместим с этим списком (необязательно)
NullPointerException - если указанный элемент равен null, а этот список не допускает элементы null (необязательно)

listIterator

ListIterator<E> listIterator()
Возвращает итератор списка по элементам этого списка (в надлежащем порядке).
Возвращает:
итератор списка по элементам этого списка (в надлежащем порядке)

listIterator

ListIterator<E> listIterator(int index)
Возвращает итератор списка по элементам этого списка (в надлежащем порядке), начиная с указанной позиции. Указанный индекс обозначает первый элемент, который будет возвращён при первоначальном вызове next. Первоначальный вызов previous вернёт элемент с индексом на единицу меньше указанного.
Параметры:
index - индекс первого элемента, который будет возвращён итератором списка (при вызове next)
Возвращает:
итератор списка по элементам этого списка (в надлежащем порядке), начиная с указанной позиции
Выбрасывает:
IndexOutOfBoundsException - если индекс выходит за допустимый диапазон (index < 0 || index > size())

subList

List<E> subList(int fromIndex, int toIndex)
Возвращает представление части этого списка между указанными fromIndex включительно и toIndex исключительно. (Если fromIndex и toIndex равны, возвращаемый список пуст.) Возвращаемый список основан на этом списке, поэтому структурные изменения возвращаемого списка отражаются в этом списке, и наоборот. Возвращаемый список поддерживает все необязательные операции со списками, поддерживаемые этим списком.

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

     list.subList(from, to).clear();
Аналогичные идиоматические способы можно составить для indexOf и lastIndexOf, а все алгоритмы класса Collections можно применять к subList.

Семантика списка, возвращаемого этим методом, становится неопределенной, если базовый список (то есть этот список) подвергается структурной модификации каким-либо способом, отличным от операций через возвращаемый список. (Структурные модификации — это изменения размера списка или иные изменения, из-за которых выполняющиеся итерации могут давать неверные результаты.)

Параметры:
fromIndex — нижняя граница (включительно) subList
toIndex — верхняя граница (исключительно) subList
Возвращает:
представление указанного диапазона в этом списке
Вызывает:
IndexOutOfBoundsException — если значение индекса конечной точки недопустимо (fromIndex < 0 || toIndex > size || fromIndex > toIndex)

spliterator

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

Spliterator сообщает о характеристиках Spliterator.SIZED и Spliterator.ORDERED. В реализациях следует документировать сообщение о дополнительных значениях характеристик.

Определено в:
spliterator в интерфейсе Collection<E>
Определено в:
spliterator в интерфейсе Iterable<E>
Требования к реализации:
Реализация по умолчанию создает сплитератор с отложенной привязкой следующим образом:
  • Если список является экземпляром RandomAccess, реализация по умолчанию создает сплитератор, который обходит элементы, вызывая метод get(int). Если такой вызов приводит или мог бы привести к IndexOutOfBoundsException, сплитератор обнаружит это и выбросит ConcurrentModificationException. Если список также является экземпляром AbstractList, сплитератор будет использовать поле modCount списка, чтобы обеспечить дополнительную защиту от таких изменений.
  • В противном случае реализация по умолчанию создает сплитератор из Iterator списка. Сплитератор наследует поведение итератора списка при обнаружении изменений.
Примечание по реализации:
Созданный Spliterator дополнительно сообщает о характеристике Spliterator.SUBSIZED.
Возвращает:
Spliterator для элементов этого списка
С версии:
1.8

addFirst

default void addFirst(E e)
Добавляет элемент в начало этой коллекции (необязательная операция). После успешного завершения этой операции указанный элемент будет входить в эту коллекцию и станет первым элементом в порядке обхода.
Определено в:
addFirst в интерфейсе SequencedCollection<E>
Требования к реализации:
Реализация в этом интерфейсе вызывает add(0, e).
Параметры:
e — добавляемый элемент
Вызывает:
NullPointerException — если указанный элемент равен null, а эта коллекция не допускает элементы null
UnsupportedOperationException — если эта реализация коллекции не поддерживает данную операцию
С версии:
21

addLast

default void addLast(E e)
Добавляет элемент в конец этой коллекции (необязательная операция). После успешного завершения этой операции указанный элемент будет входить в эту коллекцию и станет последним элементом в порядке обхода.
Определено в:
addLast в интерфейсе SequencedCollection<E>
Требования к реализации:
Реализация в этом интерфейсе вызывает add(e).
Параметры:
e — добавляемый элемент.
Вызывает:
NullPointerException — если указанный элемент равен null, а эта коллекция не допускает элементы null
UnsupportedOperationException — если эта реализация коллекции не поддерживает данную операцию
С версии:
21

getFirst

default E getFirst()
Возвращает первый элемент этой коллекции.
Определено в:
getFirst в интерфейсе SequencedCollection<E>
Требования к реализации:
Если этот список не пуст, реализация в этом интерфейсе возвращает результат вызова get(0). В противном случае она выбрасывает NoSuchElementException.
Возвращает:
извлеченный элемент
Вызывает:
NoSuchElementException — если эта коллекция пуста
С версии:
21

getLast

default E getLast()
Возвращает последний элемент этой коллекции.
Определено в:
getLast в интерфейсе SequencedCollection<E>
Требования к реализации:
Если этот список не пуст, реализация в этом интерфейсе возвращает результат вызова get(size() - 1). В противном случае она выбрасывает NoSuchElementException.
Возвращает:
извлеченный элемент
Вызывает:
NoSuchElementException — если эта коллекция пуста
С версии:
21

removeFirst

default E removeFirst()
Удаляет и возвращает первый элемент этой коллекции (необязательная операция).
Определено в:
removeFirst в интерфейсе SequencedCollection<E>
Требования к реализации:
Если этот список не пуст, реализация в этом интерфейсе возвращает результат вызова remove(0). В противном случае она выбрасывает NoSuchElementException.
Возвращает:
удаленный элемент
Вызывает:
NoSuchElementException — если эта коллекция пуста
UnsupportedOperationException — если эта реализация коллекции не поддерживает данную операцию
С версии:
21

removeLast

default E removeLast()
Удаляет и возвращает последний элемент этой коллекции (необязательная операция).
Определено в:
removeLast в интерфейсе SequencedCollection<E>
Требования к реализации:
Если этот список не пуст, реализация в этом интерфейсе возвращает результат вызова remove(size() - 1). В противном случае она выбрасывает NoSuchElementException.
Возвращает:
удаленный элемент
Вызывает:
NoSuchElementException — если эта коллекция пуста
UnsupportedOperationException — если эта реализация коллекции не поддерживает данную операцию
С версии:
21

reversed

default List<E> reversed()
Возвращает представление этой коллекции с обратным порядком. Порядок обхода элементов в возвращаемом представлении является обратным порядку обхода элементов в этой коллекции. Обратный порядок влияет на все операции, чувствительные к порядку, включая операции над представлениями-коллекциями возвращаемого представления. Если реализация коллекции допускает изменение этого представления, такие изменения «передаются» базовой коллекции. Изменения базовой коллекции могут быть видны или не видны в этом представлении с обратным порядком — это зависит от реализации.
Определено в:
reversed в интерфейсе SequencedCollection<E>
Требования к реализации:
Реализация в этом интерфейсе возвращает представление списка с обратным порядком. Метод reversed() этого представления возвращает ссылку на этот список. Другие операции с представлением реализуются посредством вызовов открытых методов этого списка. Точная связь между вызовами для представления и вызовами для этого списка не определена. Однако операции, чувствительные к порядку, обычно ведут себя так, как если бы они делегировали вызов соответствующему методу с противоположной ориентацией. Например, вызов getFirst для представления может привести к вызову getLast для этого списка.
Возвращает:
представление этой коллекции с обратным порядком в виде List
С версии:
21

of

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

of

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

of

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

of

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

of

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

of

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

of

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

of

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

of

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

of

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

of

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

of

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

copyOf

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

ofLazy

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

Возвращаемый список является немодифицируемым; его элементы лениво вычисляются с помощью предоставленной computingFunction при первом обращении к ним (например, через List::get).

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

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

Все сбои обрабатываются таким образом. Есть два особых случая, при которых выбрасываются непроверяемые исключения:

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

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

Элементы любых представлений subList() или reversed() возвращаемого списка также вычисляются лениво.

Возвращаемый список, а также его представления subList() или reversed() реализуют интерфейс RandomAccess.

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

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

Возвращаемый список не является сериализуемым.

Рассмотрим пример приложения, в котором используются три отдельных OrderController компонента. В зависимости от идентификатора потока выбирается один из трех компонентов OrderController. Использование ленивого списка гарантирует, что будет создано не более трех экземпляров OrderController. После создания получение компонента может быть оптимизировано JVM посредством свертки констант:

class Application {

    private static final int POOL_SIZE = 3;

    static final List<OrderController> ORDERS
        = List.ofLazy(POOL_SIZE, _ -> new OrderController());

    public static OrderController orders() {
        long index = Thread.currentThread().threadId() % POOL_SIZE;
        return ORDERS.get((int)index);
    }

     // Eligible for constant folding
     OrderController orders = orders();
}
Возвращаемый List<E> можно рассматривать как список, основанный на поле List<LazyConstant<E>>, где операция get(int) эквивалентна следующей:
 class LazyList<E> extends AbstractList<E> {

     private final List<LazyConstant<E>> backingList;

     public LazyList(int size, IntFunction<E> computingFunction) {
         this.backingList = IntStream.range(0, size)
                 .mapToObj(i -> LazyConstant.of(() -> computingFunction.apply(i)))
                 .toList();
     }

     @Override
     public E get(int index) {
         return backingList.get(index).get();
     }
 }
Однако производительность и эффективность использования памяти могут быть выше.

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

Примечание по реализации:
После успешной инициализации всех элементов или их перехода в состояние ошибки сильная ссылка на функцию вычисления больше не хранится, и она может быть удалена сборщиком мусора.
Параметры типа:
E — тип элементов возвращаемого списка
Параметры:
size — размер возвращаемого ленивого списка
computingFunction — функция, вызываемая при первом обращении к элементу (не должна возвращать null)
Возвращает:
новый список, элементы которого лениво вычисляются с помощью предоставленной size
Вызывает:
IllegalArgumentException — если предоставленное size отрицательно.
NullPointerException — если предоставленное computingFunction равно null
С версии:
26
См. также:
  • LazyConstantPREVIEW

Сообщить об ошибке или предложить улучшение
Для получения дополнительных справочных материалов по 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