Интерфейс MemorySegment

public sealed interface MemorySegment

MemorySegment является предварительным API платформы Java.

Программы могут использовать MemorySegment только при включенных предварительных функциях.

Предварительные функции могут быть удалены в будущих выпусках или обновлены до постоянных функций платформы Java.

Сегмент памяти предоставляет доступ к непрерывной области памяти.

Существуют два типа сегментов памяти:

Сегмент кучи поддерживается и предоставляет доступ к области памяти внутри кучи Java (область "в куче").
Сегмент нативного типа поддерживается и предоставляет доступ к области памяти за пределами кучи Java (область "вне кучи").

Сегменты кучи можно получить, вызвав один из методов-фабрик ofArray(int[]). Эти методы возвращают сегмент памяти, поддерживаемый областью в куче, которая содержит указанный массив Java.

Сегменты нативного типа можно получить, вызвав один из методов-фабрик Arena.allocate(long, long)^{ПРЕДПРОСМОТР}, которые возвращают сегмент памяти, поддерживаемый только что выделенной областью вне кучи с заданным размером и выровненным по заданному ограничению выравнивания. В качестве альтернативы, сегменты нативного типа можно получить, mapping^{ПРЕДПРОСМОТР} файл в новую область вне кучи (в некоторых системах эта операция иногда называется mmap). Сегменты, полученные таким образом, называются отображенными сегментами, и их содержимое может быть сохранено и загружено в подлежащий файл с отображением памяти.

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

Характеристики сегментов памяти

Каждый сегмент памяти имеет адрес, выраженный в виде long значения. Характер адреса сегмента зависит от его типа:

Адрес сегмента кучи — это не физический адрес, а смещение в области памяти, которая поддерживает сегмент. Область находится внутри кучи Java, поэтому сборка мусора может привести к перемещению области в физической памяти со временем, но это не отображается клиентам API MemorySegment, которые видят стабильный виртуализированный адрес сегмента кучи, поддерживаемого областью. Сегмент кучи, полученный из одного из методов-фабрик ofArray(int[]), имеет адрес 0.
Адрес сегмента нативного типа (включая отображенные сегменты) обозначает физический адрес области памяти, которая поддерживает сегмент.

Каждый сегмент памяти имеет размер. Размер сегмента кучи определяется из массива Java, из которого он получен. Этот размер предсказуем в разных средах выполнения Java. Размер сегмента нативного типа либо явно передается (как в Arena.allocate(long, long)^{ПРЕДПРОСМОТР}), либо определяется из MemoryLayout^{ПРЕДПРОСМОТР} (как в SegmentAllocator.allocate(MemoryLayout)^{ПРЕДПРОСМОТР}). Размер сегмента памяти обычно является положительным числом, но может быть нулевым, но никогда отрицательным.

Адрес и размер сегмента памяти совместно гарантируют, что операции доступа к сегменту не могут выйти за пределы границ области памяти, которая поддерживает сегмент. То есть сегмент памяти имеет пространственные границы.

Каждый сегмент памяти связан с областью^{ПРЕДПРОСМОТР}. Это гарантирует, что операции доступа к сегменту памяти не могут выполняться, когда область памяти, которая поддерживает сегмент памяти, больше недоступна (например, после того, как область, связанная с обращением к сегменту памяти, больше не активна^{ПРЕДПРОСМОТР}). То есть у сегмента памяти есть временные границы.

Наконец, операции доступа к сегменту памяти могут быть подвержены дополнительным проверкам изоляции потоков. К сегментам кучи можно получить доступ из любого потока. Напротив, к сегментам нативного типа можно получить доступ в соответствии с характеристиками изоляции потоков аренды, используемой для их получения.

Доступ к сегментам памяти

Сегмент памяти можно читать или записывать с помощью различных операций доступа, предоставляемых в этом классе (например, get(ValueLayout.OfInt, long)). Каждая операция доступа принимает вид представления данных^{ПРЕДПРОСМОТР}, который определяет размер и структуру данных, и смещение, выраженное в байтах. Например, для чтения int из сегмента, используя стандартное порядок байтов, можно использовать следующий код:

MemorySegment segment = ...
int value = segment.get(ValueLayout.JAVA_INT, 0);

Если данные, подлежащие чтению, хранятся в памяти с использованием кодировки big-endian, операция доступа может быть выражена следующим образом:

MemorySegment segment = ...
int value = segment.get(ValueLayout.JAVA_INT.withOrder(BIG_ENDIAN), 0);

Для более сложных операций доступа (например, структурного доступа к памяти) клиенты могут получить переменную-обработчик^{ПРЕДПРОСМОТР}, которая принимает сегмент и long смещение. Более сложные переменные-обработчики могут быть получены путем адаптации переменной-обработчика сегмента, используя функции комбинации переменных-обработчиков, определенные в классе MethodHandles:

MemorySegment segment = ...
VarHandle intHandle = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_INT);
MethodHandle multiplyExact = MethodHandles.lookup()
                                          .findStatic(Math.class, "multiplyExact",
                                                                  MethodType.methodType(long.class, long.class, long.class));
intHandle = MethodHandles.filterCoordinates(intHandle, 1,
                                            MethodHandles.insertArguments(multiplyExact, 0, ValueLayout.JAVA_INT.byteSize()));
int value = (int) intHandle.get(segment, 3L); // get int element at offset 3 * 4 = 12

В качестве альтернативы, сложные переменные-обработчики могут быть получены из способов представления данных^{ПРЕДПРОСМОТР}, предоставив так называемый путь представления данных:

MemorySegment segment = ...
VarHandle intHandle = ValueLayout.JAVA_INT.arrayElementVarHandle();
int value = (int) intHandle.get(segment, 3L); // get int element at offset 3 * 4 = 12

Вырезка сегментов памяти

Сегменты памяти поддерживают вырезку. Вырезка сегмента памяти возвращает новый сегмент памяти, поддерживаемый той же областью памяти, что и исходный. Адрес вырезанного сегмента получен из адреса исходного сегмента путем добавления смещения (выраженного в байтах). Размер вырезанного сегмента либо неявно определяется (путем вычитания указанного смещения из размера исходного сегмента), либо задается явно. Другими словами, вырезанный сегмент имеет более строгие пространственные границы, чем исходный сегмент:

 Arena arena = ...
 MemorySegment segment = arena.allocate(100);
 MemorySegment slice = segment.asSlice(50, 10);
 slice.get(ValueLayout.JAVA_INT, 20); // Out of bounds!
 arena.close();
 slice.get(ValueLayout.JAVA_INT, 0); // Already closed!

Вышеприведенный код создает сегмент нативного типа длиной 100 байтов; затем он создает вырезку, начинающуюся со смещения 50 сегмента segment, и длиной 10 байтов. То есть адрес slice составляет segment.address() + 50, а его размер равен 10. В результате попытка чтения значения int со смещением 20 в сегменте slice приведет к исключению. Временные границы^{ПРЕДПРОСМОТР} исходного сегмента наследуются его вырезками; то есть, когда область, связанная с segment больше не активна^{ПРЕДПРОСМОТР}, slice также станет недоступным.

Клиент может получить Stream из сегмента, который затем можно использовать для вырезки сегмента (в соответствии с заданным представлением элемента) и даже разрешить нескольким потокам работать параллельно над отдельными вырезками сегмента (для этого сегмент должен быть доступен из нескольких потоков). Следующий код можно использовать для вычисления суммы всех значений int в сегменте памяти параллельно:

 try (Arena arena = Arena.ofShared()) {
     SequenceLayout SEQUENCE_LAYOUT = MemoryLayout.sequenceLayout(1024, ValueLayout.JAVA_INT);
     MemorySegment segment = arena.allocate(SEQUENCE_LAYOUT);
     int sum = segment.elements(ValueLayout.JAVA_INT).parallel()
                      .mapToInt(s -> s.get(ValueLayout.JAVA_INT, 0))
                      .sum();
 }

Выравнивание

Операции доступа к сегменту памяти ограничены не только пространственными и временными границами сегмента, но и ограничением выравнивания вида представления данных, указанного для операции. Операция доступа может получить доступ только к тем смещениям в сегменте, которые обозначают адреса в физической памяти, выровненные в соответствии с представлением данных. Адрес в физической памяти выровнен в соответствии с представлением данных, если адрес является целым кратным ограничению выравнивания представления данных. Например, адрес 1000 выровнен в соответствии с ограничением выравнивания 8 байтов (поскольку 1000 является целым кратным 8) и по ограничению выравнивания 4 байта и 2 байта; напротив, адрес 1004 выровнен в соответствии с ограничением выравнивания 4 байта и 2 байта, но не с ограничением выравнивания 8 байтов. Операции доступа должны соблюдать выравнивание, поскольку это может повлиять на производительность операций доступа и также определить, какие операции доступа доступны по заданному физическому адресу. Например, атомарные операции доступа, использующие VarHandle, разрешены только по выровненным адресам. Кроме того, выравнивание применяется к операции доступа, независимо от того, является ли обращаемый сегмент сегментом нативного типа или сегментом кучи.

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

boolean isAligned(MemorySegment segment, long offset, MemoryLayout layout) {
  return ((segment.address() + offset) % layout.byteAlignment()) == 0;
}

Например:

К родному сегменту с адресом 1000 можно получить доступ по смещениям 0, 8, 16, 24 и т. д. при ограничении выравнивания 8 байт, так как целевые адреса (1000, 1008, 1016, 1024) выровнены по 8 байтам. Доступ по смещениям 1-7 или 9-15 или 17-23 запрещен, так как целевые адреса не будут выровнены по 8 байтам.
К родному сегменту с адресом 1000 можно получить доступ по смещениям 0, 4, 8, 12 и т. д. при ограничении выравнивания 4 байта, так как целевые адреса (1000, 1004, 1008, 1012) выровнены по 4 байтам. Доступ по смещениям 1-3 или 5-7 или 9-11 запрещен, так как целевые адреса не будут выровнены по 4 байтам.
К родному сегменту с адресом 1000 можно получить доступ по смещениям 0, 2, 4, 6 и т. д. при ограничении выравнивания 2 байта, так как целевые адреса (1000, 1002, 1004, 1006) выровнены по 2 байтам. Доступ по смещениям 1 или 3 или 5 запрещен, так как целевые адреса не будут выровнены по 2 байтам.
К родному сегменту с адресом 1004 можно получить доступ по смещениям 0, 4, 8, 12 и т. д. при ограничении выравнивания 4 байта, и по смещениям 0, 2, 4, 6 и т. д. при ограничении выравнивания 2 байта. При ограничении выравнивания 8 байт, к нему можно получить доступ по смещениям 4, 12, 20, 28 и т. д.
К родному сегменту с адресом 1006 можно получить доступ по смещениям 0, 2, 4, 6 и т. д. при ограничении выравнивания 2 байта. При ограничении выравнивания 4 байта, к нему можно получить доступ по смещениям 2, 6, 10, 14 и т. д. При ограничении выравнивания 8 байт, к нему можно получить доступ по смещениям 2, 10, 18, 26 и т. д.
К родному сегменту с адресом 1007 можно получить доступ по смещениям 0, 1, 2, 3 и т. д. при ограничении выравнивания 1 байта. При ограничении выравнивания 2 байта, к нему можно получить доступ по смещениям 1, 3, 5, 7 и т. д. При ограничении выравнивания 4 байта, к нему можно получить доступ по смещениям 1, 5, 9, 13 и т. д. При ограничении выравнивания 8 байт, к нему можно получить доступ по смещениям 1, 9, 17, 25 и т. д.

Ограничение выравнивания, используемое для доступа к сегменту, обычно определяется формой структуры данных, хранящейся в сегменте. Например, если программист хочет хранить последовательность значений по 8 байт в родном сегменте, то сегмент должен быть выделен, указав ограничение выравнивания по 8 байтам, либо через Arena.allocate(long, long)^PREVIEW, либо через SegmentAllocator.allocate(MemoryLayout)^PREVIEW. Эти фабрики гарантируют, что начальный адрес области памяти вне кучи, поддерживающей возвращаемый сегмент, выровнен по 8 байтам. После этого программист может получить доступ к сегменту по смещениям, которые его интересуют — 0, 8, 16, 24 и т. д. — зная, что каждый такой доступ выровнен.

Если доступный сегмент является сегментом кучи, то определение того, выровнен ли доступ, более сложно. Адрес сегмента в физической памяти неизвестен и даже не фиксирован (он может измениться при перемещении сегмента во время сборки мусора). Это означает, что адрес нельзя объединить со смещением, чтобы определить целевой адрес в физической памяти. Поскольку ограничение выравнивания всегда относится к выравниванию адресов в физической памяти, принципиально невозможно определить, выровнено ли какое-либо смещение в сегменте кучи. Например, предположим, что программист выбирает ограничение выравнивания по 8 байтам и пытается получить доступ к смещению 16 в сегменте кучи. Если адрес сегмента кучи 0 соответствует физическому адресу 1000, то целевой адрес (1016) будет выровнен, но если адрес 0 соответствует физическому адресу 1004, то целевой адрес (1020) не будет выровнен. Нежелательно разрешать доступ к целевым адресам, которые выровнены в соответствии с выбранным программистом ограничением выравнивания, но могут не быть предсказуемо выровнены в физической памяти (например, из-за особенностей платформы и/или поведения сборки мусора).

На практике среда выполнения Java размещает массивы в памяти таким образом, что каждый элемент размером n байт находится по физическому адресу, выровненному по n байтам (за исключением long[] и double[], где выравнивание зависит от платформы, как объяснено ниже). Среда выполнения сохраняет это свойство даже если массив перемещается во время сборки мусора. Операции доступа полагаются на это свойство, чтобы определить, относится ли указанное смещение в сегменте кучи к выровненному адресу в физической памяти. Например:

Начальный физический адрес массива short[] будет выровнен по 2 байтам (например, 1006), чтобы последующие короткие элементы располагались по адресам, выровненным по 2 байтам (например, 1006, 1008, 1010, 1012 и т. д.). Сегмент кучи, поддерживаемый массивом short[], может быть доступен по смещениям 0, 2, 4, 6 и т. д. при ограничении выравнивания 2 байта. К сегменту нельзя получить доступ ни по одному смещению при ограничении выравнивания 4 байта, так как нет гарантии, что целевой адрес будет выровнен по 4 байтам, например, смещение 0 будет соответствовать физическому адресу 1006, а смещение 1 — физическому адресу 1007. Аналогично, к сегменту нельзя получить доступ ни по одному смещению при ограничении выравнивания 8 байт, так как нет гарантии, что целевой адрес будет выровнен по 8 байтам, например, смещение 2 будет соответствовать физическому адресу 1008, а смещение 4 — физическому адресу 1010.
Начальный физический адрес массива long[] будет выровнен по 8 байтам (например, 1000) на 64-битных платформах, чтобы последующие длинные элементы располагались по адресам, выровненным по 8 байтам (например, 1000, 1008, 1016, 1024 и т. д.). На 64-битных платформах сегмент кучи, поддерживаемый массивом long[], может быть доступен по смещениям 0, 8, 16, 24 и т. д. при ограничении выравнивания 8 байт. Кроме того, к сегменту можно получить доступ по смещениям 0, 4, 8, 12 и т. д. при ограничении выравнивания 4 байта, так как целевые адреса (1000, 1004, 1008, 1012) выровнены по 4 байтам. И к сегменту можно получить доступ по смещениям 0, 2, 4, 6 и т. д. при ограничении выравнивания 2 байта, так как целевые адреса (например, 1000, 1002, 1004, 1006) выровнены по 2 байтам.
Начальный физический адрес массива long[] будет выровнен по 4 байтам (например, 1004) на 32-битных платформах, чтобы последующие длинные элементы располагались по адресам, выровненным по 4 байтам (например, 1004, 1008, 1012, 1016 и т. д.). На 32-битных платформах сегмент кучи, поддерживаемый массивом long[], может быть доступен по смещениям 0, 4, 8, 12 и т. д. при ограничении выравнивания 4 байта, так как целевые адреса (1004, 1008, 1012, 1016) выровнены по 4 байтам. И к сегменту можно получить доступ по смещениям 0, 2, 4, 6 и т. д. при ограничении выравнивания 2 байта, так как целевые адреса (например, 1000, 1002, 1004, 1006) выровнены по 2 байтам.

Другими словами, сегменты кучи имеют (зависимое от платформы) максимальное выравнивание, которое выводится из размера элементов массива Java, поддерживающего сегмент, как показано в следующей таблице:

Максимальное выравнивание сегментов кучи

Тип массива (поддерживающей области) Максимальное поддерживаемое выравнивание (в байтах)

boolean[] ValueLayout.JAVA_BOOLEAN.byteAlignment()

byte[] ValueLayout.JAVA_BYTE.byteAlignment()

char[] ValueLayout.JAVA_CHAR.byteAlignment()

short[] ValueLayout.JAVA_SHORT.byteAlignment()

int[] ValueLayout.JAVA_INT.byteAlignment()

float[] ValueLayout.JAVA_FLOAT.byteAlignment()

long[] ValueLayout.JAVA_LONG.byteAlignment()

double[] ValueLayout.JAVA_DOUBLE.byteAlignment()

Максимальное выравнивание сегментов кучи
Тип массива (поддерживающей области)	Максимальное поддерживаемое выравнивание (в байтах)
`boolean[]`	`ValueLayout.JAVA_BOOLEAN.byteAlignment()`
`byte[]`	`ValueLayout.JAVA_BYTE.byteAlignment()`
`char[]`	`ValueLayout.JAVA_CHAR.byteAlignment()`
`short[]`	`ValueLayout.JAVA_SHORT.byteAlignment()`
`int[]`	`ValueLayout.JAVA_INT.byteAlignment()`
`float[]`	`ValueLayout.JAVA_FLOAT.byteAlignment()`
`long[]`	`ValueLayout.JAVA_LONG.byteAlignment()`
`double[]`	`ValueLayout.JAVA_DOUBLE.byteAlignment()`

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

MemorySegment byteSegment = MemorySegment.ofArray(new byte[10]);
byteSegment.get(ValueLayout.JAVA_INT, 0); // fails: ValueLayout.JAVA_INT.byteAlignment() > ValueLayout.JAVA_BYTE.byteAlignment()

В таких ситуациях у клиентов есть два варианта. Они могут использовать сегмент кучи, поддерживаемый другим типом массива (например, long[]), способным поддерживать большее максимальное выравнивание. Более конкретно, максимальное выравнивание, связанное с long[], установлено в ValueLayout.JAVA_LONG.byteAlignment(), что является значением, зависящим от платформы (установленным в ValueLayout.ADDRESS.byteSize()). То есть long[]) гарантирует по крайней мере 8-байтовое выравнивание на 64-битных платформах, но только 4-байтовое выравнивание на 32-битных платформах:

MemorySegment longSegment = MemorySegment.ofArray(new long[10]);
longSegment.get(ValueLayout.JAVA_INT, 0); // ok: ValueLayout.JAVA_INT.byteAlignment() <= ValueLayout.JAVA_LONG.byteAlignment()

В качестве альтернативы они могут вызвать операцию доступа с невыровненным макетом. Все константы невыровненных макетов (например, ValueLayout.JAVA_INT_UNALIGNED^PREVIEW) имеют ограничение выравнивания, установленное в 1:

MemorySegment byteSegment = MemorySegment.ofArray(new byte[10]);
byteSegment.get(ValueLayout.JAVA_INT_UNALIGNED, 0); // ok: ValueLayout.JAVA_INT_UNALIGNED.byteAlignment() == ValueLayout.JAVA_BYTE.byteAlignment()

Сегменты памяти нулевой длины

При взаимодействии с внешними функциями эти функции часто выделяют область памяти и возвращают указатель на эту область. Моделирование области памяти с помощью сегмента памяти затруднено, так как среда выполнения Java не имеет информации о размере области. Доступен только адрес начала области, хранящийся в указателе. Например, функция C с типом возврата char* может вернуть указатель на область, содержащую одно значение char, или на область, содержащую массив значений char, где размер массива может быть предоставлен в отдельном параметре. Размер массива не очевиден для кода, вызывающего внешнюю функцию и надеющегося использовать её результат. Кроме того, что у него нет информации о размере области памяти, поддерживающей указатель, возвращённый внешней функцией, он также не имеет информации о предполагаемом сроке жизни этой области памяти со стороны внешней функции, которая её выделила.

API MemorySegment использует сегменты памяти нулевой длины для представления:

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

Адрес сегмента нулевой длины — это адрес, хранящийся в указателе. Пространственные и временные границы сегмента нулевой длины следующие:

Размер сегмента равен нулю. Любая попытка доступа к этим сегментам завершится ошибкой IndexOutOfBoundsException. Это важная функция безопасности: поскольку эти сегменты связаны с областью памяти, размер которой неизвестен, любые операции доступа, включающие эти сегменты, не могут быть валидированы. По сути, сегмент памяти нулевой длины оборачивает адрес, и его нельзя использовать без явного намерения (см. ниже);
Сегмент связан со свежим, всегда активным областью видимости. Таким образом, хотя к сегментам памяти нулевой длины нельзя получить прямой доступ, их можно передавать (скрыто) другим функциям, принимающим указатели.

Чтобы продемонстрировать, как клиенты могут работать с сегментами памяти нулевой длины, рассмотрим случай клиента, который хочет прочитать указатель из некоторого сегмента памяти. Это можно сделать с помощью метода доступа get(AddressLayout, long). Этот метод принимает макет адреса^{ПРОСМОТР} (например, ValueLayout.ADDRESS^{ПРОСМОТР}), макет указателя, который нужно прочитать. Например, на 64-битной платформе размер макета адреса составляет 8 байт. Операция доступа также принимает смещение, выраженное в байтах, которое указывает позицию (относительно начала сегмента памяти), в которой хранится указатель. Операция доступа возвращает сегмент памяти нулевой длины, поддерживаемый областью памяти, начальный адрес которой равен 64-битному значению, прочитанному по указанному смещению.

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

 MemorySegment z = segment.get(ValueLayout.ADDRESS, ...);   // size = 0
 MemorySegment ptr = z.reinterpret(16);                     // size = 16
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);           // ok

В некоторых случаях клиенту может потребоваться дополнительно назначить новые временные границы сегменту памяти нулевой длины. Это можно сделать с помощью метода reinterpret(long, Arena, Consumer), который возвращает новый сегмент с требуемым размером и теми же временными границами, что и предоставленной области:

 MemorySegment ptr = null;
 try (Arena arena = Arena.ofConfined()) {
       MemorySegment z = segment.get(ValueLayout.ADDRESS, ...);    // size = 0, scope = always alive
       ptr = z.reinterpret(16, arena, null);                       // size = 4, scope = arena.scope()
       int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);            // ok
 }
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);                  // throws IllegalStateException

В качестве альтернативы, если размер области памяти, поддерживающей сегмент памяти нулевой длины, известен статически, клиент может наложить целевой макет^{ПРОСМОТР} на макет адреса, используемый при чтении указателя. Целевой макет затем используется для динамического расширения размера сегмента памяти, возвращаемого операцией доступа, таким образом, что размер сегмента совпадает с размером целевого макета. Другими словами, возвращаемый сегмент больше не является сегментом памяти нулевой длины, и указатель, который он представляет, может быть непосредственно разыменован:

 AddressLayout intArrPtrLayout = ValueLayout.ADDRESS.withTargetLayout(
         MemoryLayout.sequenceLayout(4, ValueLayout.JAVA_INT)); // layout for int (*ptr)[4]
 MemorySegment ptr = segment.get(intArrPtrLayout, ...);         // size = 16
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);               // ok

Все методы, которые могут использоваться для управления сегментами памяти нулевой длины (reinterpret(long), reinterpret(Arena, Consumer), reinterpret(long, Arena, Consumer) и AddressLayout.withTargetLayout(MemoryLayout)^{ПРОСМОТР}) являются ограниченными методами и должны использоваться с осторожностью: назначение сегменту неправильных пространственных и/или временных границ может привести к сбою виртуальной машины при попытке доступа к сегменту памяти.

Требования к реализации:: Реализации этого интерфейса неизменяемы, потокобезопасны и базирующиеся на значениях.
С:: 19

Краткое описание вложенных классов

Модификатор и тип	Интерфейс	Описание
`static interface`	`MemorySegment.Scope^PREVIEW`	Просмотр. Область видимости моделирует жизненный цикл всех сегментов памяти, связанных с ней.

Краткое описание полей

Модификатор и тип	Поле	Описание
`static final MemorySegment^PREVIEW`	`NULL`	Сегмент нулевой длины, моделирующий адрес `NULL`.

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

Modifier and Type	Method	Description
`long`	`address()`	Возвращает адрес этого сегмента памяти.
`ByteBuffer`	`asByteBuffer()`	Оборачивает этот сегмент в `ByteBuffer`.
`Optional<MemorySegment^PREVIEW>`	`asOverlappingSlice(MemorySegment^PREVIEW other)`	Возвращает срез этого сегмента, который представляет собой область перекрытия между этим и предоставленным сегментом.
`MemorySegment^PREVIEW`	`asReadOnly()`	Возвращает только для чтения представление этого сегмента.
`MemorySegment^PREVIEW`	`asSlice(long offset)`	Возвращает срез этого сегмента памяти по указанному смещению.
`MemorySegment^PREVIEW`	`asSlice(long offset, long newSize)`	Возвращает срез этого сегмента памяти по указанному смещению.
`MemorySegment^PREVIEW`	`asSlice(long offset, long newSize, long byteAlignment)`	Возвращает срез этого сегмента памяти по указанному смещению с ограничением выравнивания.
`default MemorySegment^PREVIEW`	`asSlice(long offset, MemoryLayout^PREVIEW layout)`	Возвращает срез этого сегмента памяти с заданной структурой по указанному смещению.
`long`	`byteSize()`	Возвращает размер (в байтах) этого сегмента памяти.
`static void`	`copy(MemorySegment^PREVIEW srcSegment, long srcOffset, MemorySegment^PREVIEW dstSegment, long dstOffset, long bytes)`	Выполняет копирование блока из исходного сегмента в целевой сегмент.
`static void`	`copy(MemorySegment^PREVIEW srcSegment, ValueLayout^PREVIEW srcElementLayout, long srcOffset, MemorySegment^PREVIEW dstSegment, ValueLayout^PREVIEW dstElementLayout, long dstOffset, long elementCount)`	Выполняет копирование блока из исходного сегмента в целевой сегмент.
`static void`	`copy(MemorySegment^PREVIEW srcSegment, ValueLayout^PREVIEW srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)`	Копирует количество элементов из исходного сегмента памяти в целевой массив.
`static void`	`copy(Object srcArray, int srcIndex, MemorySegment^PREVIEW dstSegment, ValueLayout^PREVIEW dstLayout, long dstOffset, int elementCount)`	Копирует количество элементов из исходного массива в целевой сегмент памяти.
`default MemorySegment^PREVIEW`	`copyFrom(MemorySegment^PREVIEW src)`	Выполняет копирование блока из заданного исходного сегмента в этот сегмент.
`Stream<MemorySegment^PREVIEW>`	`elements(MemoryLayout^PREVIEW elementLayout)`	Возвращает последовательность `Stream` по непересекающимся срезам (размер которых соответствует заданной структуре) в этом сегменте.
`boolean`	`equals(Object that)`	Сравнивает указанный объект с этим сегментом памяти на равенство.
`MemorySegment^PREVIEW`	`fill(byte value)`	Заполняет содержимое этого сегмента памяти заданным значением.
`void`	`force()`	Принудительно записывает все изменения, внесенные в содержимое этого сопоставленного сегмента, в устройство хранения, описанное дескриптором файла сопоставленного сегмента.
`default MemorySegment^PREVIEW`	`get(AddressLayout^PREVIEW layout, long offset)`	Считывает адрес из этого сегмента по указанному смещению с заданной структурой.
`default boolean`	`get(ValueLayout.OfBoolean^PREVIEW layout, long offset)`	Считывает булево значение из этого сегмента по указанному смещению с заданной структурой.
`default byte`	`get(ValueLayout.OfByte^PREVIEW layout, long offset)`	Считывает байт из этого сегмента по указанному смещению с заданной структурой.
`default char`	`get(ValueLayout.OfChar^PREVIEW layout, long offset)`	Считывает символ из этого сегмента по указанному смещению с заданной структурой.
`default double`	`get(ValueLayout.OfDouble^PREVIEW layout, long offset)`	Считывает значение типа double из этого сегмента по указанному смещению с заданной структурой.
`default float`	`get(ValueLayout.OfFloat^PREVIEW layout, long offset)`	Считывает значение типа float из этого сегмента по указанному смещению с заданной структурой.
`default int`	`get(ValueLayout.OfInt^PREVIEW layout, long offset)`	Считывает значение типа int из этого сегмента по указанному смещению с заданной структурой.
`default long`	`get(ValueLayout.OfLong^PREVIEW layout, long offset)`	Считывает значение типа long из этого сегмента по указанному смещению с заданной структурой.
`default short`	`get(ValueLayout.OfShort^PREVIEW layout, long offset)`	Считывает значение типа short из этого сегмента по указанному смещению с заданной структурой.
`default MemorySegment^PREVIEW`	`getAtIndex(AddressLayout^PREVIEW layout, long index)`	Считывает адрес из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default boolean`	`getAtIndex(ValueLayout.OfBoolean^PREVIEW layout, long index)`	Считывает булево значение из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default byte`	`getAtIndex(ValueLayout.OfByte^PREVIEW layout, long index)`	Считывает байт из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default char`	`getAtIndex(ValueLayout.OfChar^PREVIEW layout, long index)`	Считывает символ из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default double`	`getAtIndex(ValueLayout.OfDouble^PREVIEW layout, long index)`	Считывает значение типа double из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default float`	`getAtIndex(ValueLayout.OfFloat^PREVIEW layout, long index)`	Считывает значение типа float из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default int`	`getAtIndex(ValueLayout.OfInt^PREVIEW layout, long index)`	Считывает значение типа int из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default long`	`getAtIndex(ValueLayout.OfLong^PREVIEW layout, long index)`	Считывает значение типа long из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default short`	`getAtIndex(ValueLayout.OfShort^PREVIEW layout, long index)`	Считывает значение типа short из этого сегмента по указанному индексу, масштабированному по размеру заданной структуры.
`default String`	`getUtf8String(long offset)`	Считывает строку UTF-8, завершенную нулем, из этого сегмента по указанному смещению.
`int`	`hashCode()`	Возвращает хэш-код этого сегмента памяти.
`Optional<Object>`	`heapBase()`	Возвращает объект Java, хранящийся в области кучи памяти, поддерживающей этот сегмент памяти, если таковой имеется.
`boolean`	`isAccessibleBy(Thread thread)`	Возвращает `true`, если к этому сегменту можно получить доступ из указанной нити.
`boolean`	`isLoaded()`	Определяет, находится ли содержимое этого сопоставленного сегмента в физической памяти.
`boolean`	`isMapped()`	Возвращает `true`, если этот сегмент является сопоставленным сегментом.
`boolean`	`isNative()`	Возвращает `true`, если этот сегмент является нативным сегментом.
`boolean`	`isReadOnly()`	Возвращает `true`, если этот сегмент только для чтения.
`void`	`load()`	Загружает содержимое этого сопоставленного сегмента в физическую память.
`default long`	`mismatch(MemorySegment^PREVIEW other)`	Находит и возвращает смещение (в байтах) первой несовпадения между этим сегментом и указанным другим сегментом.
`static long`	`mismatch(MemorySegment^PREVIEW srcSegment, long srcFromOffset, long srcToOffset, MemorySegment^PREVIEW dstSegment, long dstFromOffset, long dstToOffset)`	Находит и возвращает относительное смещение (в байтах) первой несовпадения между исходным и целевыми сегментами.
`static MemorySegment^PREVIEW`	`ofAddress(long address)`	Создаёт нативный сегмент нулевой длины из заданного значения адреса.
`static MemorySegment^PREVIEW`	`ofArray(byte[] byteArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, содержащей заданный массив байтов.
`static MemorySegment^PREVIEW`	`ofArray(char[] charArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, содержащей заданный массив символов.
`static MemorySegment^PREVIEW`	`ofArray(double[] doubleArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, содержащей заданный массив значений типа double.
`static MemorySegment^PREVIEW`	`ofArray(float[] floatArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, содержащей заданный массив значений типа float.
`static MemorySegment^PREVIEW`	`ofArray(int[] intArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, содержащей заданный массив значений типа int.
`static MemorySegment^PREVIEW`	`ofArray(long[] longArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, содержащей заданный массив значений типа long.
`static MemorySegment^PREVIEW`	`ofArray(short[] shortArray)`	Создаёт сегмент памяти, поддерживаемый той же областью памяти, что и заданный экземпляр `Buffer`.

`MemorySegment^PREVIEW`	`reinterpret(long newSize)`	Возвращает новый сегмент памяти, у которого тот же адрес и область действия, что и у этого сегмента, но с указанным размером.
`MemorySegment^PREVIEW`	`reinterpret(long newSize, Arena^PREVIEW arena, Consumer<MemorySegment^PREVIEW> cleanup)`	Возвращает новый сегмент с тем же адресом, что и у этого сегмента, но с указанным размером и областью действия.
`MemorySegment^PREVIEW`	`reinterpret(Arena^PREVIEW arena, Consumer<MemorySegment^PREVIEW> cleanup)`	Возвращает новый сегмент памяти с тем же адресом и размером, что и у этого сегмента, но с указанной областью действия.
`MemorySegment.Scope^PREVIEW`	`scope()`	Возвращает область действия, связанную с этим сегментом памяти.
`long`	`segmentOffset(MemorySegment^PREVIEW other)`	Возвращает смещение, в байтах, указанного сегмента относительно этого сегмента.
`default void`	`set(AddressLayout^PREVIEW layout, long offset, MemorySegment^PREVIEW value)`	Записывает адрес в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfBoolean^PREVIEW layout, long offset, boolean value)`	Записывает булево значение в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfByte^PREVIEW layout, long offset, byte value)`	Записывает байт в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfChar^PREVIEW layout, long offset, char value)`	Записывает символ в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfDouble^PREVIEW layout, long offset, double value)`	Записывает double в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfFloat^PREVIEW layout, long offset, float value)`	Записывает float в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfInt^PREVIEW layout, long offset, int value)`	Записывает int в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfLong^PREVIEW layout, long offset, long value)`	Записывает long в этот сегмент по заданному смещению с заданной структурой.
`default void`	`set(ValueLayout.OfShort^PREVIEW layout, long offset, short value)`	Записывает short в этот сегмент по заданному смещению с заданной структурой.
`default void`	`setAtIndex(AddressLayout^PREVIEW layout, long index, MemorySegment^PREVIEW value)`	Записывает адрес в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfBoolean^PREVIEW layout, long index, boolean value)`	Записывает булево значение в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfByte^PREVIEW layout, long index, byte value)`	Записывает байт в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfChar^PREVIEW layout, long index, char value)`	Записывает символ в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfDouble^PREVIEW layout, long index, double value)`	Записывает double в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfFloat^PREVIEW layout, long index, float value)`	Записывает float в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfInt^PREVIEW layout, long index, int value)`	Записывает int в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfLong^PREVIEW layout, long index, long value)`	Записывает long в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setAtIndex(ValueLayout.OfShort^PREVIEW layout, long index, short value)`	Записывает short в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`default void`	`setUtf8String(long offset, String str)`	Записывает заданную строку в этот сегмент по заданному смещению, преобразуя её в последовательность байтов с нулевым завершением с использованием кодировки UTF-8.
`Spliterator<MemorySegment^PREVIEW>`	`spliterator(MemoryLayout^PREVIEW elementLayout)`	Возвращает итератор для этого сегмента памяти.
`byte[]`	`toArray(ValueLayout.OfByte^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив байтов.
`char[]`	`toArray(ValueLayout.OfChar^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив символов.
`double[]`	`toArray(ValueLayout.OfDouble^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив double.
`float[]`	`toArray(ValueLayout.OfFloat^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив float.
`int[]`	`toArray(ValueLayout.OfInt^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив int.
`long[]`	`toArray(ValueLayout.OfLong^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив long.
`short[]`	`toArray(ValueLayout.OfShort^PREVIEW elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив short.
`void`	`unload()`	Выгружает содержимое этого отображенного сегмента из физической памяти.

Подробное описание полей

NULL

static final MemorySegmentPREVIEW NULL

Сегмент с нулевой длиной, представляющий NULL адрес.

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

address

long address()

Возвращает адрес этого сегмента памяти.

Примечание API:: При использовании этого метода для передачи адреса сегмента во внешнюю операцию (например, функцию JNI), клиенты должны убедиться, что сегмент остаётся доступным на протяжении всего выполнения операции. Невыполнение этого требования может привести к преждевременному освобождению области памяти, поддерживающей сегмент, в случае, если сегмент был выделен с помощью автоматической арены^ПРЕВЬЮ.
Возвращает:: адрес этого сегмента памяти

heapBase

Optional<Object> heapBase()

Возвращает Java-объект, хранящийся в куче (on-heap) области памяти, поддерживающей этот сегмент памяти, если таковой имеется. Например, если этот сегмент памяти является сегментом кучи, созданным с помощью метода-фабрики ofArray(byte[]), этот метод вернёт byte[] объект, который использовался для получения сегмента. Этот метод возвращает пустое Optional значение, если сегмент является нативным или если он только для чтения.

Возвращает:: Java-объект, связанный с этим сегментом памяти, если таковой имеется.

spliterator

Spliterator<MemorySegmentPREVIEW> spliterator(MemoryLayoutPREVIEW elementLayout)

Возвращает разделитель для этого сегмента памяти. Возвращаемый разделитель сообщает о характеристиках Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.IMMUTABLE, Spliterator.NONNULL и Spliterator.ORDERED.

Возвращаемый разделитель разбивает этот сегмент в соответствии со заданным расположением элементов; то есть, если предоставленное расположение имеет размер N, вызов Spliterator.trySplit() приведет к разделителю, обслуживающему приблизительно S/N элементов (в зависимости от чётности N), где S - это размер этого сегмента. Таким образом, разделение возможно, пока S/N >= 2. Разделитель возвращает сегменты, которые имеют тот же срок жизни, что и этот сегмент.

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

Параметры:: elementLayout - расположение, используемое для разделения.
Возвращает:: разделитель элементов для этого сегмента
Исключения:: IllegalArgumentException - если elementLayout.byteSize() == 0.; IllegalArgumentException - если byteSize() % elementLayout.byteSize() != 0.; IllegalArgumentException - если elementLayout.byteSize() % elementLayout.byteAlignment() != 0.; IllegalArgumentException - если этот сегмент несовместим с ограничением выравнивания в предоставленном расположении.

elements

Stream<MemorySegmentPREVIEW> elements(MemoryLayoutPREVIEW elementLayout)

Возвращает последовательный Stream по непересекающимся срезам (размер которых соответствует размеру указанного расположения) в этом сегменте. Вызов этого метода эквивалентен следующему коду:

StreamSupport.stream(segment.spliterator(elementLayout), false);

Параметры:: elementLayout - расположение, используемое для разделения.
Возвращает:: последовательный Stream по непересекающимся срезам в этом сегменте.
Исключения:: IllegalArgumentException - если elementLayout.byteSize() == 0.; IllegalArgumentException - если byteSize() % elementLayout.byteSize() != 0.; IllegalArgumentException - если elementLayout.byteSize() % elementLayout.byteAlignment() != 0.; IllegalArgumentException - если этот сегмент несовместим с ограничением выравнивания в предоставленном расположении.

scope

MemorySegment.ScopePREVIEW scope()

Возвращает область, связанную с этим сегментом памяти.

Возвращает:: область, связанную с этим сегментом памяти

isAccessibleBy

boolean isAccessibleBy(Thread thread)

Возвращает true значение, если к этому сегменту можно получить доступ из предоставленного потока.

Параметры:: thread - проверяемый поток.
Возвращает:: true , если к этому сегменту можно получить доступ из предоставленного потока

byteSize

long byteSize()

Возвращает размер (в байтах) этого сегмента памяти.

Возвращает:: размер (в байтах) этого сегмента памяти

asSlice

MemorySegmentPREVIEW asSlice(long offset, long newSize)

Возвращает срез этого сегмента памяти по заданному смещению. Адрес возвращаемого сегмента — это адрес этого сегмента плюс заданное смещение; его размер определяется заданным аргументом.

Эквивалентно следующему коду:

asSlice(offset, newSize, 1);

Параметры:

offset - Новое смещение начала сегмента (относительно адреса этого сегмента), указанное в байтах.

newSize - Новый размер сегмента, указанный в байтах.

Возвращает:

срез этого сегмента памяти.

Исключения:

IndexOutOfBoundsException - если offset < 0, offset > byteSize(), newSize < 0, или newSize > byteSize() - offset

См. также:

asSlice

MemorySegmentPREVIEW asSlice(long offset, long newSize, long byteAlignment)

Возвращает срез этого сегмента памяти по заданному смещению, с заданным ограничением выравнивания. Адрес возвращаемого сегмента — это адрес этого сегмента плюс заданное смещение; его размер определяется заданным аргументом.

Параметры:: offset - Новое смещение начала сегмента (относительно адреса этого сегмента), указанное в байтах.; newSize - Новый размер сегмента, указанный в байтах.; byteAlignment - Ограничение выравнивания (в байтах) возвращаемого среза.
Возвращает:: срез этого сегмента памяти.
Исключения:: IndexOutOfBoundsException - если offset < 0, offset > byteSize(), newSize < 0, или newSize > byteSize() - offset; IllegalArgumentException - если к этому сегменту нельзя получить доступ по offset с указанным ограничением выравнивания.; IllegalArgumentException - если byteAlignment <= 0, или если byteAlignment не является степенью двойки.

asSlice

default MemorySegmentPREVIEW asSlice(long offset, MemoryLayoutPREVIEW layout)

Возвращает срез этого сегмента памяти с заданным расположением, по заданному смещению. Адрес возвращаемого сегмента — это адрес этого сегмента плюс заданное смещение; его размер совпадает с размером предоставленного расположения.

Эквивалентно следующему коду:

asSlice(offset, layout.byteSize(), layout.byteAlignment());

Параметры:

offset - Новое смещение начала сегмента (относительно адреса этого сегмента), указанное в байтах.

layout - Расположение среза сегмента.

Возвращает:

срез этого сегмента памяти.

Исключения:

IndexOutOfBoundsException - если offset < 0, offset > byteSize(), или layout.byteSize() > byteSize() - offset

IllegalArgumentException - если к этому сегменту нельзя получить доступ по offset с ограничением выравнивания, заданным layout.

См. также:

asSlice

MemorySegmentPREVIEW asSlice(long offset)

Возвращает срез этого сегмента памяти по заданному смещению. Адрес возвращаемого сегмента — это адрес этого сегмента плюс заданное смещение; его размер вычисляется путем вычитания заданного смещения из размера этого сегмента.

Эквивалентно следующему коду:

asSlice(offset, byteSize() - offset);

Параметры:

offset - Новое смещение начала сегмента (относительно адреса этого сегмента), указанное в байтах.

Возвращает:

срез этого сегмента памяти.

Исключения:

IndexOutOfBoundsException - если offset < 0, или offset > byteSize().

См. также:

reinterpret

MemorySegmentPREVIEW reinterpret(long newSize)

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

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

Параметры:: newSize - размер возвращаемого сегмента.
Возвращает:: новый сегмент памяти, имеющий тот же адрес и область, что и этот сегмент, но с новым указанным размером.
Исключения:: newSize < 0 - если newSize < 0.; UnsupportedOperationException - если этот сегмент не является нативным сегментом.; IllegalCallerException - Если вызывающий находится в модуле, в котором не включен доступ к нативным ресурсам.

reinterpret

MemorySegmentPREVIEW reinterpret(ArenaPREVIEW arena, Consumer<MemorySegmentPREVIEW> cleanup)

Возвращает новый сегмент памяти с тем же адресом и размером, что и этот сегмент, но с указанным областью действия. Таким образом, к возвращенному сегменту нельзя получить доступ после закрытия предоставленной области. Кроме того, к возвращенному сегменту можно получить доступ, совместимо с ограничениями изоляции, связанными с предоставленной областью: то есть, если предоставленная область — область изоляции^PREVIEW, к возвращенному сегменту можно получить доступ только потоку-владельцу области, независимо от ограничений изоляции, связанных с этим сегментом. Другими словами, этот метод возвращает сегмент, который ведет себя так, как если бы он был выделен с использованием предоставленной области.

Клиенты могут указать необязательное действие очистки, которое должно быть выполнено, когда предоставленная область действия станет недействительной. Это действие очистки получает новый сегмент памяти, который извлекается из этого сегмента следующим образом:

MemorySegment cleanupSegment = MemorySegment.ofAddress(this.address())
                                            .reinterpret(byteSize());

То есть, действие очистки получает сегмент, связанный со свежей областью, которая всегда активна и доступна из любого потока. Размер сегмента, принятого действием очистки, равен byteSize().

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

API Note:: Действие очистки (если оно присутствует) должно позаботиться о том, чтобы не утечка сегмента во внешние клиенты, которые могут получить доступ к сегменту после того, как его область памяти больше недоступна. Кроме того, если предоставленная область — область автоматической области^PREVIEW, действие очистки не должно препятствовать области стать недостижимой. Несоблюдение этого правила приведет к постоянному предотвращению освобождения областей памяти, выделенных автоматической областью.
Parameters:: arena - область, которая должна быть связана с возвращаемым сегментом.; cleanup - действие очистки, которое должно быть выполнено, когда предоставленная область закрывается (может быть null).
Returns:: новый сегмент памяти с неограниченным размером.
Throws:: IllegalStateException - если arena.scope().isAlive() == false.; UnsupportedOperationException - если этот сегмент не является нативным сегментом.; IllegalCallerException - Если вызывающий находится в модуле, в котором не включен доступ к нативным ресурсам.

reinterpret

MemorySegmentPREVIEW reinterpret(long newSize, ArenaPREVIEW arena, Consumer<MemorySegmentPREVIEW> cleanup)

Возвращает новый сегмент с тем же адресом, что и этот сегмент, но с указанным размером и областью. Таким образом, к возвращенному сегменту нельзя получить доступ после закрытия предоставленной области. Кроме того, если к возвращенному сегменту можно получить доступ, совместимо с ограничениями изоляции, связанными с предоставленной областью: то есть, если предоставленная область — область изоляции^PREVIEW, к возвращенному сегменту можно получить доступ только потоку-владельцу области, независимо от ограничений изоляции, связанных с этим сегментом. Другими словами, этот метод возвращает сегмент, который ведет себя так, как если бы он был выделен с использованием предоставленной области.

Клиенты могут указать необязательное действие очистки, которое должно быть выполнено, когда предоставленная область станет недействительной. Это действие очистки получает новый сегмент памяти, который извлекается из этого сегмента следующим образом:

MemorySegment cleanupSegment = MemorySegment.ofAddress(this.address())
                                            .reinterpret(newSize);

API Note:: Действие очистки (если оно присутствует) должно позаботиться о том, чтобы не утечка сегмента во внешние клиенты, которые могут получить доступ к сегменту после того, как его область памяти больше недоступна. Кроме того, если предоставленная область — область автоматической области^PREVIEW, действие очистки не должно препятствовать области стать недостижимой. Несоблюдение этого правила приведет к постоянному предотвращению освобождения областей памяти, выделенных автоматической областью.
Parameters:: newSize - размер возвращаемого сегмента.; arena - область, которая должна быть связана с возвращаемым сегментом.; cleanup - действие очистки, которое должно быть выполнено, когда предоставленная область закрывается (может быть null).
Returns:: новый сегмент, имеющий тот же адрес, что и этот сегмент, но с новым размером и своей областью, установленной в предоставленную область.
Throws:: UnsupportedOperationException - если этот сегмент не является нативным сегментом.; IllegalArgumentException - если newSize < 0.; IllegalStateException - если arena.scope().isAlive() == false.; IllegalCallerException - Если вызывающий находится в модуле, в котором не включен доступ к нативным ресурсам.

isReadOnly

boolean isReadOnly()

Возвращает true, если этот сегмент является только для чтения.

Returns:

true, если этот сегмент является только для чтения

See Also:

asReadOnly

MemorySegmentPREVIEW asReadOnly()

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

Returns:

представление только для чтения этого сегмента

See Also:

isNative

boolean isNative()

Возвращает true если этот сегмент является нативным сегментом. Нативный сегмент создается, например, с помощью Arena.allocate(long, long)^PREVIEW (и связанных) фабрик или путем обертывания прямого буфера.

Returns:: true если этот сегмент является нативным сегментом.

isMapped

boolean isMapped()

Возвращает true если этот сегмент является отображаемым сегментом. Отображаемый сегмент памяти создается, например, с помощью FileChannel.map(FileChannel.MapMode, long, long, Arena)^PREVIEW фабрик или путем обертывания отображаемого байтового буфера.

Returns:: true если этот сегмент является отображаемым сегментом.

asOverlappingSlice

Optional<MemorySegmentPREVIEW> asOverlappingSlice(MemorySegmentPREVIEW other)

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

Два сегмента S1 и S2 считаются перекрывающимися, если можно найти по крайней мере два среза L1 (из S1) и L2 (из S2) которые поддерживаются одной областью памяти. Таким образом, нативный сегмент не может перекрываться с сегментом кучи; в этом случае или при отсутствии перекрытия возвращается пустой Optional.

Parameters:: other - сегмент, с которым проверяется перекрытие с этим сегментом.
Returns:: срез этого сегмента (где происходит перекрытие).

segmentOffset

long segmentOffset(MemorySegmentPREVIEW other)

Возвращает смещение, в байтах, указанного сегмента, относительно этого сегмента.

Смещение относительно адреса этого сегмента и может быть отрицательным или положительным. Например, если оба сегмента являются нативными сегментами или сегментами кучи, поддерживаемыми одним и тем же массивом, результирующее смещение может быть вычислено следующим образом:

other.address() - address()

Если сегменты разделяют один адрес, возвращается 0. Если other является срезом этого сегмента, смещение всегда 0 <= x < this.byteSize().

Parameters:: other - сегмент, для которого необходимо получить смещение.
Returns:: относительное смещение, в байтах, указанного сегмента.
Throws:: UnsupportedOperationException - если два сегмента нельзя сравнить, например, потому что они разных типов или потому, что они поддерживаются разными массивами Java.

заполнить

MemorySegmentPREVIEW fill(byte value)

Заполняет содержимое этого сегмента памяти заданным значением.

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

for (long offset = 0; offset < segment.byteSize(); offset++) {
    byteHandle.set(ValueLayout.JAVA_BYTE, offset, value);
}

Но без учета или гарантий относительно порядка установки отдельных элементов памяти.

Этот метод может быть полезен для инициализации или сброса содержимого сегмента памяти.

Параметры:: value - значение для записи в этот сегмент.
Возвращает:: этот сегмент памяти.
Исключения:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; UnsupportedOperationException - если этот сегмент является только для чтения.

скопироватьИз

default MemorySegmentPREVIEW copyFrom(MemorySegmentPREVIEW src)

Выполняет копирование из заданного исходного сегмента в этот сегмент. Более точно, байты с смещением 0 по src.byteSize() - 1 в исходном сегменте копируются в этот сегмент со смещением 0 по src.byteSize() - 1.

Вызов этого метода эквивалентен следующему коду:

MemorySegment.copy(src, 0, this, 0, src.byteSize());

Параметры:: src - исходный сегмент.
Возвращает:: этот сегмент.
Исключения:: IndexOutOfBoundsException - если src.byteSize() > this.byteSize().; IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; IllegalStateException - если область действия (scope), связанная с src , не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что src.isAccessibleBy(T) == false.; UnsupportedOperationException - если этот сегмент является только для чтения.

несовпадение

default long mismatch(MemorySegmentPREVIEW other)

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

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

Параметры:: other - сегмент, проверяемый на несовпадение с этим сегментом.
Возвращает:: относительное смещение, в байтах, первого несовпадения между этим и заданным другим сегментом, в противном случае -1, если несовпадения нет.
Исключения:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; IllegalStateException - если область действия (scope), связанная с other , не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что other.isAccessibleBy(T) == false.

загружен

boolean isLoaded()

Определяет, находится ли содержимое этого сопоставленного сегмента в физической памяти.

Значение true означает, что, скорее всего, все данные в этом сегменте находятся в физической памяти и, следовательно, могут быть обработаны без возникновения страниц виртуальной памяти или операций ввода-вывода. Значение false не обязательно означает, что содержимое этого сегмента не находится в физической памяти.

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

Возвращает:: true если, вероятно, содержимое этого сегмента находится в физической памяти
Исключения:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; UnsupportedOperationException - если этот сегмент не является сопоставленным сегментом памяти, например, если isMapped() == false.

загрузить

void load()

Загружает содержимое этого сопоставленного сегмента в физическую память.

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

Исключения:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; UnsupportedOperationException - если этот сегмент не является сопоставленным сегментом памяти, например, если isMapped() == false.

разгрузить

void unload()

Выгружает содержимое этого сопоставленного сегмента из физической памяти.

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

Исключения:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; UnsupportedOperationException - если этот сегмент не является сопоставленным сегментом памяти, например, если isMapped() == false.

принудительное выполнение

void force()

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

Если дескриптор файла, связанный с этим сопоставленным сегментом, находится на локальном устройстве хранения, то по завершении этого метода гарантируется, что все изменения, внесенные в этот сегмент с момента его создания или с момента последнего вызова этого метода, будут записаны на это устройство.

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

Если этот сегмент не был сопоставлен в режиме чтения/записи (FileChannel.MapMode.READ_WRITE), вызов этого метода может не иметь эффекта. В частности, метод не имеет эффекта для сегментов, сопоставленных в режимах только для чтения или частного отображения. Для сегментов, сопоставленных в режимах, специфичных для реализации, этот метод может или не может иметь эффект.

Исключения:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, такой что isAccessibleBy(T) == false.; UnsupportedOperationException - если этот сегмент не является сопоставленным сегментом памяти, например, если isMapped() == false.; UncheckedIOException - если при записи содержимого этого сегмента на связанное устройство хранения произошла ошибка ввода-вывода

asByteBuffer

ByteBuffer asByteBuffer()

Оборачивает этот сегмент в ByteBuffer. Некоторые свойства возвращаемого буфера связаны со свойствами этого сегмента. Более конкретно, полученный буфер имеет следующие характеристики:

Он является только для чтения, если этот сегмент является сегментом только для чтения;
Его позиция установлена в ноль;
Его емкость и предел оба установлены в размер этого сегмента размер. По этой причине буфер байтов не может быть возвращен, если размер этого сегмента больше, чем Integer.MAX_VALUE;
Он является прямым буфером, если это родной сегмент.

Жизненный цикл возвращаемого буфера привязан к жизненному циклу этого сегмента. То есть, доступ к возвращаемому буферу после того, как область, связанная с этим сегментом, больше не активна^ПРЕВЬЮ, вызовет исключение IllegalStateException. Аналогично, доступ к возвращаемому буферу из потока T таким образом, что isAccessible(T) == false вызовет WrongThreadException.

Если этот сегмент доступен только из одного потока, вызов операций ввода/вывода чтения/записи на результирующем буфере может привести к тому, что будут выброшены неопределённые исключения. Примерами таких проблемных операций являются AsynchronousSocketChannel.read(ByteBuffer) и AsynchronousSocketChannel.write(ByteBuffer).

Наконец, порядок байтов результирующего буфера является ByteOrder.BIG_ENDIAN; это можно изменить с помощью ByteBuffer.order(java.nio.ByteOrder).

Возвращает:: a ByteBuffer представление этого сегмента памяти.
Исключения:: UnsupportedOperationException - если этот сегмент нельзя отобразить в экземпляр ByteBuffer, например, если это сегмент кучи, поддерживаемый массивом, отличным от byte[]), или если его размер больше, чем Integer.MAX_VALUE.

toArray

byte[] toArray(ValueLayout.OfBytePREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив байтов.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив байтов, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр byte[] , например, если его размер больше, чем Integer.MAX_VALUE.

toArray

short[] toArray(ValueLayout.OfShortPREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив short.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив short, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр short[] , например, из-за byteSize() % 2 != 0, или byteSize() / 2 > Integer.MAX_VALUE

toArray

char[] toArray(ValueLayout.OfCharPREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив char.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив char, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр char[] , например, из-за byteSize() % 2 != 0, или byteSize() / 2 > Integer.MAX_VALUE.

toArray

int[] toArray(ValueLayout.OfIntPREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив int.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив int, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр int[] , например, из-за byteSize() % 4 != 0, или byteSize() / 4 > Integer.MAX_VALUE.

toArray

float[] toArray(ValueLayout.OfFloatPREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив float.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив float, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр float[] , например, из-за byteSize() % 4 != 0, или byteSize() / 4 > Integer.MAX_VALUE.

toArray

long[] toArray(ValueLayout.OfLongPREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив long.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив long, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр long[] , например, из-за byteSize() % 8 != 0, или byteSize() / 8 > Integer.MAX_VALUE.

toArray

double[] toArray(ValueLayout.OfDoublePREVIEW elementLayout)

Копирует содержимое этого сегмента памяти в новый массив double.

Параметры:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива выполняется операция перестановки байтов.
Возвращает:: новый массив double, содержимое которого скопировано из этого сегмента памяти.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна^ПРЕВЬЮ.; WrongThreadException - если этот метод вызывается из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр double[] , например, из-за byteSize() % 8 != 0, или byteSize() / 8 > Integer.MAX_VALUE.

getUtf8String

default String getUtf8String(long offset)

Считывает строку в кодировке UTF-8, завершающуюся нулевым байтом, из этого сегмента по заданному смещению.

Этот метод всегда заменяет поврежденные входные данные и последовательности неотображаемых символов строкой замены по умолчанию для этой кодировки. Класс CharsetDecoder следует использовать, когда требуется больший контроль над процессом декодирования.

Параметры:: offset - смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться эта операция доступа.
Возвращает:: строку Java, созданную из байтов, прочитанных из заданного начального адреса до (но не включая) первого '\0' символа-разделителя (при условии, что он найден).
Исключения:: IllegalArgumentException - если размер строки UTF-8 превышает максимально допустимую длину строки, поддерживаемую платформой.; IndexOutOfBoundsException - если offset < 0 или offset > byteSize() - S, где S - размер строки UTF-8 (включая символ-разделитель).; IllegalStateException - если область видимости scope, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false.

setUtf8String

default void setUtf8String(long offset, String str)

Записывает заданную строку в этот сегмент по заданному смещению, преобразуя её в байтовую последовательность, завершающуюся нулевым байтом, используя кодировку UTF-8.

Если заданная строка содержит какие-либо '\0' символы, они также будут скопированы. Это означает, что в зависимости от метода, используемого для чтения строки, например getUtf8String(long), строка будет выглядеть усеченной при повторном чтении.

Параметры:: offset - смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться эта операция доступа. Конечный адрес этой операции записи может быть выражен как address() + offset.; str - строка Java, которая должна быть записана в этот сегмент.
Исключения:: IndexOutOfBoundsException - если offset < 0 или offset > byteSize() - str.getBytes().length() + 1.; IllegalStateException - если область видимости scope, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false.

ofBuffer

static MemorySegmentPREVIEW ofBuffer(Buffer buffer)

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

Если буфер является только для чтения, то результирующий сегмент также является только для чтения. Кроме того, если буфер является прямым буфером, возвращаемый сегмент является собственным сегментом; в противном случае возвращаемый сегмент памяти является сегментом кучи.

Если предоставленный буфер был получен путем вызова asByteBuffer() для сегмента памяти, область видимости^PREVIEW которого S, возвращаемый сегмент будет связан с той же областью видимости S. В противном случае область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна.

Область видимости, связанная с возвращаемым сегментом, поддерживает доступность предоставленного буфера. Таким образом, если предоставленный буфер является прямым буфером, его резервный регион памяти не будет освобожден, пока возвращаемый сегмент (или любой из его срезов) остается доступным.

Параметры:: buffer - экземпляр буфера, который должен быть преобразован в новый сегмент памяти.
Возвращает:: сегмент памяти, полученный из заданного экземпляра буфера.
Исключения:: IllegalArgumentException - если предоставленный buffer является буфером кучи, но не поддерживается массивом. Например, буферы, полученные непосредственно или косвенно с помощью (CharBuffer.wrap(CharSequence) или CharBuffer.wrap(char[], int, int) не поддерживаются массивом.

ofArray

static MemorySegmentPREVIEW ofArray(byte[] byteArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив байтов. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: byteArray - примитивный массив, поддерживающий сегмент памяти кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом байтов.

ofArray

static MemorySegmentPREVIEW ofArray(char[] charArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив символов. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: charArray - примитивный массив, поддерживающий сегмент кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом символов.

ofArray

static MemorySegmentPREVIEW ofArray(short[] shortArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив коротких целых чисел. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: shortArray - примитивный массив, поддерживающий сегмент кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом коротких целых чисел.

ofArray

static MemorySegmentPREVIEW ofArray(int[] intArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив целых чисел. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: intArray - примитивный массив, поддерживающий сегмент кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом целых чисел.

ofArray

static MemorySegmentPREVIEW ofArray(float[] floatArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив чисел с плавающей точкой одинарной точности. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: floatArray - примитивный массив, поддерживающий сегмент кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом чисел с плавающей точкой одинарной точности.

ofArray

static MemorySegmentPREVIEW ofArray(long[] longArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив длинных целых чисел. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: longArray - примитивный массив, поддерживающий сегмент кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом длинных целых чисел.

ofArray

static MemorySegmentPREVIEW ofArray(double[] doubleArray)

Создает сегмент кучи, поддерживаемый областью памяти в куче, которая содержит данный массив чисел с плавающей точкой двойной точности. Область видимости возвращаемого сегмента является новой областью видимости, которая всегда активна и поддерживает доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

Параметры:: doubleArray - примитивный массив, поддерживающий сегмент кучи.
Возвращает:: сегмент памяти кучи, поддерживаемый массивом чисел с плавающей точкой двойной точности.

ofAddress

static MemorySegmentPREVIEW ofAddress(long address)

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

На 32-разрядных платформах заданное значение адреса будет нормализовано таким образом, что старшие («крайние левые») 32 бита address возвращаемого сегмента памяти будут установлены в ноль.

Параметры:: address - адрес возвращаемого собственного сегмента.
Возвращает:: собственный сегмент нулевой длины с заданным адресом.

copy

static void copy(MemorySegmentPREVIEW srcSegment, long srcOffset, MemorySegmentPREVIEW dstSegment, long dstOffset, long bytes)

Выполняет массивное копирование из сегмента-источника в сегмент-назначение. Более конкретно, байты с смещением srcOffset по srcOffset + bytes - 1 в сегменте-источнике копируются в сегмент-назначение со смещением dstOffset по dstOffset + bytes - 1.

Если сегмент-источник перекрывается с сегментом-назначением, то копирование выполняется так, как будто байты со смещением srcOffset по srcOffset + bytes - 1 в сегменте-источнике сначала копируются во временный сегмент размером bytes, а затем содержимое временного сегмента копируется в сегмент-назначение со смещением dstOffset по dstOffset + bytes - 1.

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

Вызов этого метода эквивалентен следующему коду:

MemorySegment.copy(srcSegment, ValueLayout.JAVA_BYTE, srcOffset, dstSegment, ValueLayout.JAVA_BYTE, dstOffset, bytes);

Parameters:: srcSegment - сегмент-источник.; srcOffset - начальное смещение, в байтах, сегмента-источника.; dstSegment - сегмент-назначение.; dstOffset - начальное смещение, в байтах, сегмента-назначения.; bytes - количество байтов для копирования.
Throws:: IllegalStateException - если объект srcSegment не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что srcSegment.isAccessibleBy(T) == false.; IllegalStateException - если объект dstSegment не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что dstSegment.isAccessibleBy(T) == false.; IndexOutOfBoundsException - если srcOffset > srcSegment.byteSize() - bytes или если dstOffset > dstSegment.byteSize() - bytes, или если любой из srcOffset, dstOffset или bytes < 0.; UnsupportedOperationException - если dstSegment является только для чтения.

copy

static void copy(MemorySegmentPREVIEW srcSegment, ValueLayoutPREVIEW srcElementLayout, long srcOffset, MemorySegmentPREVIEW dstSegment, ValueLayoutPREVIEW dstElementLayout, long dstOffset, long elementCount)

Выполняет массивное копирование из сегмента-источника в сегмент-назначение. Более конкретно, если S — это размер элемента в байтах, байты со смещением srcOffset по srcOffset + (elementCount * S) - 1 в сегменте-источнике копируются в сегмент-назначение со смещением dstOffset по dstOffset + (elementCount * S) - 1.

Копирование происходит поэлементно: байты в сегменте-источнике интерпретируются как последовательность элементов, структура которых задаётся srcElementLayout, а байты в сегменте-назначении интерпретируются как последовательность элементов, структура которых задаётся dstElementLayout. Обе структуры элементов должны иметь одинаковый размер S. Если порядок байтов в двух структурах элементов отличается, соответствующие байты каждого копируемого элемента поменяются местами во время операции копирования.

Если сегмент-источник перекрывается с сегментом-назначением, то копирование выполняется так, как будто байты со смещением srcOffset по srcOffset + (elementCount * S) - 1 в сегменте-источнике сначала копируются во временный сегмент размером bytes, а затем содержимое временного сегмента копируется в сегмент-назначение со смещением dstOffset по dstOffset + (elementCount * S) - 1.

Parameters:: srcSegment - сегмент-источник.; srcElementLayout - структура элемента, связанная с сегментом-источником.; srcOffset - начальное смещение, в байтах, сегмента-источника.; dstSegment - сегмент-назначение.; dstElementLayout - структура элемента, связанная с сегментом-назначением.; dstOffset - начальное смещение, в байтах, сегмента-назначения.; elementCount - количество элементов для копирования.
Throws:: IllegalArgumentException - если структуры элементов имеют разные размеры, если сегмент/смещение источника (соответственно назначения) несовместимы с ограничением выравнивания в структуре элемента источника (соответственно назначения), или если выравнивание структуры элемента источника (соответственно назначения) больше его размера.; IllegalStateException - если объект srcSegment не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что srcSegment().isAccessibleBy(T) == false.; IllegalStateException - если объект dstSegment не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что dstSegment().isAccessibleBy(T) == false.; UnsupportedOperationException - если dstSegment является только для чтения.; IndexOutOfBoundsException - если elementCount * srcLayout.byteSize() или elementCount * dtsLayout.byteSize() переполняется.; IndexOutOfBoundsException - если dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize()).; IndexOutOfBoundsException - если любой из srcOffset, dstOffset или elementCount < 0.

get

default byte get(ValueLayout.OfBytePREVIEW layout, long offset)

Считывает байт из этого сегмента по заданному смещению с заданной структурой.

Parameters:: layout - структура области памяти для чтения.; offset - смещение в байтах (относительно адреса этого сегмента), по которому произойдёт операция доступа.
Returns:: значение байта, считаного из этого сегмента.
Throws:: IllegalStateException - если объект этого сегмента не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

set

default void set(ValueLayout.OfBytePREVIEW layout, long offset, byte value)

Записывает байт в этот сегмент по заданному смещению с заданной структурой.

Parameters:: layout - структура области памяти для записи.; offset - смещение в байтах (относительно адреса этого сегмента), по которому произойдёт операция доступа.; value - значение байта для записи.
Throws:: IllegalStateException - если объект этого сегмента не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

get

default boolean get(ValueLayout.OfBooleanPREVIEW layout, long offset)

Считывает булево значение из этого сегмента по заданному смещению с заданной структурой.

Parameters:: layout - структура области памяти для чтения.; offset - смещение в байтах (относительно адреса этого сегмента), по которому произойдёт операция доступа.
Returns:: значение булева типа, считаного из этого сегмента.
Throws:: IllegalStateException - если объект этого сегмента не активен^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызван из потока T, такой что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

set

default void set(ValueLayout.OfBooleanPREVIEW layout, long offset, boolean value)

Записывает булево значение в этот сегмент по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть записана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.; value - значение булевого типа, которое должно быть записано.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент только для чтения.

get

default char get(ValueLayout.OfCharPREVIEW layout, long offset)

Считывает символ из этого сегмента по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть считана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.
Returns:: значение символа, считано из этого сегмента.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

set

default void set(ValueLayout.OfCharPREVIEW layout, long offset, char value)

Записывает символ в этот сегмент по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть записана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.; value - значение символа, которое должно быть записано.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент только для чтения.

get

default short get(ValueLayout.OfShortPREVIEW layout, long offset)

Считывает short из этого сегмента по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть считана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.
Returns:: значение short, считано из этого сегмента.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

set

default void set(ValueLayout.OfShortPREVIEW layout, long offset, short value)

Записывает short в этот сегмент по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть записана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.; value - значение short, которое должно быть записано.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент только для чтения.

get

default int get(ValueLayout.OfIntPREVIEW layout, long offset)

Считывает int из этого сегмента по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть считана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.
Returns:: значение int, считано из этого сегмента.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

set

default void set(ValueLayout.OfIntPREVIEW layout, long offset, int value)

Записывает int в этот сегмент по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть записана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.; value - значение int, которое должно быть записано.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент только для чтения.

get

default float get(ValueLayout.OfFloatPREVIEW layout, long offset)

Считывает float из этого сегмента по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть считана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.
Returns:: значение float, считано из этого сегмента.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

set

default void set(ValueLayout.OfFloatPREVIEW layout, long offset, float value)

Записывает float в этот сегмент по заданному смещению с заданным представлением.

Parameters:: layout - представление области памяти, которая должна быть записана.; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт данная операция доступа.; value - значение float, которое должно быть записано.
Throws:: IllegalStateException - если область действия (scope), связанная с этим сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания (ограничение выравнивания) в предоставленном представлении.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент только для чтения.

получить

default long get(ValueLayout.OfLongPREVIEW layout, long offset)

Считывает значение типа long из этого сегмента по заданному смещению с заданной структурой.

Параметры:: layout - структура области памяти для чтения.; offset - смещение в байтах (относительно адреса этого сегмента) для данной операции доступа.
Возвращает:: значение типа long, считанное из этого сегмента.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

установить

default void set(ValueLayout.OfLongPREVIEW layout, long offset, long value)

Записывает значение типа long в этот сегмент по заданному смещению с заданной структурой.

Параметры:: layout - структура области памяти для записи.; offset - смещение в байтах (относительно адреса этого сегмента) для данной операции доступа.; value - значение типа long для записи.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

получить

default double get(ValueLayout.OfDoublePREVIEW layout, long offset)

Считывает значение типа double из этого сегмента по заданному смещению с заданной структурой.

Параметры:: layout - структура области памяти для чтения.; offset - смещение в байтах (относительно адреса этого сегмента) для данной операции доступа.
Возвращает:: значение типа double, считанное из этого сегмента.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

установить

default void set(ValueLayout.OfDoublePREVIEW layout, long offset, double value)

Записывает значение типа double в этот сегмент по заданному смещению с заданной структурой.

Параметры:: layout - структура области памяти для записи.; offset - смещение в байтах (относительно адреса этого сегмента) для данной операции доступа.; value - значение типа double для записи.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

получить

default MemorySegmentPREVIEW get(AddressLayoutPREVIEW layout, long offset)

Считывает адрес из этого сегмента по заданному смещению с заданной структурой. Считанный адрес упаковывается в нативный сегмент, связанный со свежей областью видимости, которая всегда активна. В нормальных условиях размер возвращаемого сегмента равен 0. Однако, если предоставленная структура адреса имеет целевую структуру^{ПРЕДПРОСМОТР} T, тогда размер возвращаемого сегмента равен T.byteSize().

Параметры:: layout - структура области памяти для чтения.; offset - смещение в байтах (относительно адреса этого сегмента) для данной операции доступа.
Возвращает:: нативный сегмент, содержащий считанный адрес.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IllegalArgumentException - если предоставленная структура адреса имеет целевую структуру^{ПРЕДПРОСМОТР} T, и адрес возвращаемого сегмента несовместим с ограничением выравнивания в T.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().

установить

default void set(AddressLayoutPREVIEW layout, long offset, MemorySegmentPREVIEW value)

Записывает адрес в этот сегмент по заданному смещению с заданной структурой.

Параметры:: layout - структура области памяти для записи.; offset - смещение в байтах (относительно адреса этого сегмента) для данной операции доступа.; value - значение адреса для записи.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре.; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.; UnsupportedOperationException - если value не является нативным сегментом.

получитьПоИндексу

default byte getAtIndex(ValueLayout.OfBytePREVIEW layout, long index)

Считывает байт из этого сегмента по заданному индексу, масштабированному размером заданной структуры.

Параметры:: layout - структура области памяти для чтения.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента) для данной операции доступа может быть выражено как (index * layout.byteSize()).
Возвращает:: значение типа байт, считанное из этого сегмента.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре или если выравнивание структуры больше её размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

получитьПоИндексу

default boolean getAtIndex(ValueLayout.OfBooleanPREVIEW layout, long index)

Считывает значение типа boolean из этого сегмента по заданному индексу, масштабированному размером заданной структуры.

Параметры:: layout - структура области памяти для чтения.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента) для данной операции доступа может быть выражено как (index * layout.byteSize()).
Возвращает:: значение типа boolean, считанное из этого сегмента.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна (alive)^{ПРЕДПРОСМОТР}.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной структуре или если выравнивание структуры больше её размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

getAtIndex

default char getAtIndex(ValueLayout.OfCharPREVIEW layout, long index)

Читает символ из этого сегмента по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для чтения.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение типа char, прочитанное из этого сегмента.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(ValueLayout.OfCharPREVIEW layout, long index, char value)

Записывает символ в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для записи.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение типа char, которое нужно записать.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

getAtIndex

default short getAtIndex(ValueLayout.OfShortPREVIEW layout, long index)

Читает значение типа short из этого сегмента по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для чтения.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение типа short, прочитанное из этого сегмента.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(ValueLayout.OfBytePREVIEW layout, long index, byte value)

Записывает байт в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для записи.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение типа byte, которое нужно записать.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

setAtIndex

default void setAtIndex(ValueLayout.OfBooleanPREVIEW layout, long index, boolean value)

Записывает boolean в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для записи.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение типа short, которое нужно записать.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

setAtIndex

default void setAtIndex(ValueLayout.OfShortPREVIEW layout, long index, short value)

Записывает значение типа short в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для записи.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение типа short, которое нужно записать.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

getAtIndex

default int getAtIndex(ValueLayout.OfIntPREVIEW layout, long index)

Читает значение типа int из этого сегмента по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти для чтения.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором произойдёт операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение типа int, прочитанное из этого сегмента.
Исключения:: IllegalStateException - если область области доступ к которому связан с данным сегментом, не активна^PREVIEW.; WrongThreadException - если этот метод вызван из потока T, так что isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете или если выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(ValueLayout.OfIntPREVIEW layout, long index, int value)

Записывает целое число типа int в этот сегмент по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть записана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение int, которое должно быть записано.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

getAtIndex

default float getAtIndex(ValueLayout.OfFloatPREVIEW layout, long index)

Считывает значение float из этого сегмента по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть считана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Returns:: значение float, считанное из этого сегмента.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(ValueLayout.OfFloatPREVIEW layout, long index, float value)

Записывает значение float в этот сегмент по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть записана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение float, которое должно быть записано.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

getAtIndex

default long getAtIndex(ValueLayout.OfLongPREVIEW layout, long index)

Считывает значение long из этого сегмента по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть считана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Returns:: значение long, считанное из этого сегмента.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(ValueLayout.OfLongPREVIEW layout, long index, long value)

Записывает значение long в этот сегмент по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть записана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение long, которое должно быть записано.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

getAtIndex

default double getAtIndex(ValueLayout.OfDoublePREVIEW layout, long index)

Считывает значение double из этого сегмента по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть считана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Returns:: значение double, считанное из этого сегмента.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(ValueLayout.OfDoublePREVIEW layout, long index, double value)

Записывает значение double в этот сегмент по заданному индексу, масштабируя по размеру заданного макета.

Parameters:: layout - макет области памяти, которая должна быть записана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение double, которое должно быть записано.
Throws:: IllegalStateException - если область области видимости, связанная с этим сегментом, не является активной^PREVIEW.; WrongThreadException - если этот метод вызывается из потока T, при этом isAccessibleBy(T) == false.; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или выравнивание макета больше его размера.; IndexOutOfBoundsException - если index * byteSize() переполняется.; IndexOutOfBoundsException - если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException - если этот сегмент является только для чтения.

getAtIndex

default MemorySegmentPREVIEW getAtIndex(AddressLayoutPREVIEW layout, long index)

Читает адрес из этого сегмента по заданному индексу, масштабируя его размером заданного макета. Читаемый адрес обернут в родной сегмент, связанный со свежим, всегда живым, пространством. В нормальных условиях размер возвращаемого сегмента — 0. Однако, если предоставленный макет адреса имеет целевой макет^{ПОДПРЕДПРОЕКТ} T, то размер возвращаемого сегмента устанавливается в T.byteSize().

Parameters:: layout — макет области памяти для чтения.; index — логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет происходить операция доступа, может быть выражено как (index * layout.byteSize()).
Returns:: родной сегмент, содержащий адрес, прочитанный из этого сегмента.
Throws:: IllegalStateException — если область видимости, связанная с этим сегментом, не жива^{ПОДПРЕДПРОЕКТ}.; WrongThreadException — если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false.; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или если выравнивание макета больше его размера.; IllegalArgumentException — если предоставленный макет адреса имеет целевой макет^{ПОДПРЕДПРОЕКТ} T, и адрес возвращаемого сегмента несовместим с ограничением выравнивания в T.; IndexOutOfBoundsException — если index * byteSize() переполняется.; IndexOutOfBoundsException — если index * byteSize() > byteSize() - layout.byteSize().

setAtIndex

default void setAtIndex(AddressLayoutPREVIEW layout, long index, MemorySegmentPREVIEW value)

Записывает адрес в этот сегмент по заданному индексу, масштабируя его размером заданного макета.

Parameters:: layout — макет области памяти для записи.; index — логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет происходить операция доступа, может быть выражено как (index * layout.byteSize()).; value — значение адреса для записи.
Throws:: IllegalStateException — если область видимости, связанная с этим сегментом, не жива^{ПОДПРЕДПРОЕКТ}.; WrongThreadException — если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false.; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в предоставленном макете, или если выравнивание макета больше его размера.; IndexOutOfBoundsException — если index * byteSize() переполняется.; IndexOutOfBoundsException — если index * byteSize() > byteSize() - layout.byteSize().; UnsupportedOperationException — если этот сегмент является только для чтения.; UnsupportedOperationException — если value не является родным сегментом.

equals

boolean equals(Object that)

Сравнивает указанный объект с этим сегментом памяти на равенство. Возвращает true тогда и только тогда, когда указанный объект также является сегментом памяти, и если оба сегмента ссылаются на одно и то же местоположение в некоторой области памяти. Более конкретно, для двух сегментов s1 и s2 для того, чтобы считаться равными, должны выполняться все следующие условия:

s1.heapBase().equals(s2.heapBase()), то есть два сегмента должны быть одного типа; оба являются родными сегментами, поддерживаемыми вне кучей, или оба поддерживаются одной кучей объект Java;
s1.address() == s2.address(), то есть адреса двух сегментов должны быть одинаковыми. Это означает, что два сегмента либо ссылаются на одно и то же местоположение в некоторой внекучной области, либо они ссылаются на одно и то же смещение внутри своего связанного объекта Java.

Overrides:

equals в классе Object

API Note:

Этот метод не выполняет структурного сравнения содержимого двух сегментов памяти. Клиенты могут структурно сравнивать сегменты памяти, используя метод mismatch(MemorySegment) вместо этого. Обратите внимание, что этот метод не сравнивает временные и пространственные границы двух сегментов. Таким образом, он подходит для проверки, имеют ли два сегмента один и тот же адрес.

Parameters:

that — объект, который нужно сравнить на равенство с этим сегментом памяти.

Returns:

true если указанный объект равен этому сегменту памяти.

See Also:

hashCode

int hashCode()

Возвращает значение хэш-кода для этого сегмента памяти.

Overrides:

hashCode в классе Object

Returns:

значение хэш-кода для этого сегмента памяти

See Also:

copy

static void copy(MemorySegmentPREVIEW srcSegment, ValueLayoutPREVIEW srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)

Копирует заданное количество элементов из исходного сегмента памяти в целевой массив. Элементы, размер и ограничения выравнивания которых заданы данным макетом, считываются из исходного сегмента, начиная с заданного смещения (выраженного в байтах), и копируются в целевой массив по заданному индексу. Поддерживаемые типы массивов — byte[], char[], short[], int[], float[], long[] и double[].

Parameters:: srcSegment — исходный сегмент.; srcLayout — макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива будет выполнена операция перестановки байтов.; srcOffset — начальное смещение в байтах исходного сегмента.; dstArray — целевой массив.; dstIndex — начальный индекс целевого массива.; elementCount — количество элементов массива для копирования.
Throws:: IllegalStateException — если область видимости, связанная с srcSegment, не жива^{ПОДПРЕДПРОЕКТ}.; WrongThreadException — если этот метод вызывается из потока T, при котором srcSegment().isAccessibleBy(T) == false.; IllegalArgumentException — если dstArray не является массивом, или если это массив, но его тип не поддерживается.; IllegalArgumentException — если тип компонента целевого массива не соответствует srcLayout.carrier().; IllegalArgumentException — если offset несовместим с ограничением выравнивания в макете исходного элемента.; IllegalArgumentException — если srcLayout.byteAlignment() > srcLayout.byteSize().; IndexOutOfBoundsException — если elementCount * srcLayout.byteSize() переполняется.; IndexOutOfBoundsException — если srcOffset > srcSegment.byteSize() - (elementCount * srcLayout.byteSize()).; IndexOutOfBoundsException — если dstIndex > dstArray.length - elementCount.; IndexOutOfBoundsException — если srcOffset, dstIndex или elementCount являются < 0.

копировать

static void copy(Object srcArray, int srcIndex, MemorySegmentPREVIEW dstSegment, ValueLayoutPREVIEW dstLayout, long dstOffset, int elementCount)

Копирует определенное количество элементов из исходного массива в целевой сегмент памяти. Элементы, размер и ограничения выравнивания которых задаются заданным макетом, считываются из исходного массива, начиная с указанного индекса, и копируются в целевой сегмент по заданному смещению (в байтах). Поддерживаемые типы массивов — byte[], char[], short[], int[], float[], long[] и double[].

Параметры:: srcArray — исходный массив.; srcIndex — начальный индекс исходного массива.; dstSegment — целевой сегмент.; dstLayout — макет элемента назначения. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива будет выполнена операция перестановки байтов.; dstOffset — начальное смещение в байтах целевого сегмента.; elementCount — количество элементов массива, подлежащих копированию.
Исключения:: IllegalStateException — если область, связанная с dstSegment, не активна^{ПРЕДПРОСМОТР}.; WrongThreadException — если этот метод вызывается из потока T, при этом dstSegment().isAccessibleBy(T) == false.; IllegalArgumentException — если srcArray не является массивом или если это массив, но его тип не поддерживается.; IllegalArgumentException — если тип компонента исходного массива не соответствует srcLayout.carrier().; IllegalArgumentException — если offset несовместим с ограничением выравнивания в макете элемента источника.; IllegalArgumentException — если dstLayout.byteAlignment() > dstLayout.byteSize().; UnsupportedOperationException — если dstSegment является только для чтения.; IndexOutOfBoundsException — если значение elementCount * dstLayout.byteSize() выходит за пределы.; IndexOutOfBoundsException — если dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize()).; IndexOutOfBoundsException — если srcIndex > srcArray.length - elementCount.; IndexOutOfBoundsException — если любой из srcIndex, dstOffset или elementCount является < 0.

несовпадение

static long mismatch(MemorySegmentPREVIEW srcSegment, long srcFromOffset, long srcToOffset, MemorySegmentPREVIEW dstSegment, long dstFromOffset, long dstToOffset)

Находит и возвращает относительное смещение в байтах первого несовпадения между исходными и целевыми сегментами. Более конкретно, байты со смещением srcFromOffset по srcToOffset - 1 в исходном сегменте сравниваются с байтами со смещением dstFromOffset по dstToOffset - 1 в целевом сегменте.

Если два сегмента в указанных диапазонах имеют общий префикс, возвращаемое смещение представляет длину общего префикса, и это означает, что несовпадение между двумя сегментами существует на этом относительном смещении в соответствующих сегментах. Если один сегмент является правильным префиксом другого в указанных диапазонах, возвращаемое смещение — наименьший диапазон, и это означает, что относительное смещение является допустимым только для сегмента с большим диапазоном. В противном случае несовпадения нет, и возвращается -1.

Параметры:

srcSegment — исходный сегмент.

srcFromOffset — смещение (включительно) первого байта в исходном сегменте для проверки.

srcToOffset — смещение (исключительно) последнего байта в исходном сегменте для проверки.

dstSegment — целевой сегмент.

dstFromOffset — смещение (включительно) первого байта в целевом сегменте для проверки.

dstToOffset — смещение (исключительно) последнего байта в целевом сегменте для проверки.

Возвращает:

относительное смещение в байтах первого несовпадения между исходными и целевыми сегментами, в противном случае -1, если несовпадения нет.

Исключения:

IllegalStateException — если область, связанная с srcSegment, не активна^{ПРЕДПРОСМОТР}.

WrongThreadException — если этот метод вызывается из потока T, при этом srcSegment.isAccessibleBy(T) == false.

IllegalStateException — если область, связанная с dstSegment, не активна^{ПРЕДПРОСМОТР}.

WrongThreadException — если этот метод вызывается из потока T, при этом dstSegment.isAccessibleBy(T) == false.

IndexOutOfBoundsException — если srcFromOffset < 0, srcToOffset < srcFromOffset или srcToOffset > srcSegment.byteSize()

IndexOutOfBoundsException — если dstFromOffset < 0, dstToOffset < dstFromOffset или dstToOffset > dstSegment.byteSize()

См. также:

© 1993, 2023, 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.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/foreign/MemorySegment.html