Интерфейс MemorySegment

public sealed interface MemorySegment

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

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

Сегмент кучи размещается в области памяти внутри кучи Java и обеспечивает доступ к ней (области «в куче»).
Нативный сегмент размещается в области памяти вне кучи Java и обеспечивает доступ к ней (области «вне кучи»).

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

Нативные сегменты можно получить, вызвав один из фабричных методов Arena.allocate(long, long), которые возвращают сегмент памяти, размещённый в новой области вне кучи, выделенной заданного размера и выровненной с учётом заданного ограничения на выравнивание. В качестве альтернативы нативные сегменты можно получить, mapping файл в новую область вне кучи (в некоторых системах эта операция иногда называется mmap). Полученные таким образом сегменты называются отображёнными, а их содержимое можно сохранять в файл и загружать из базового файла, отображённого в память.

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

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

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

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

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

Каждый сегмент памяти имеет размер. Размер сегмента кучи определяется массивом Java, из которого он получен. Этот размер предсказуем для разных сред выполнения Java. Размер нативного сегмента либо задаётся явно (как в случае с Arena.allocate(long, long)), либо определяется по MemoryLayout (как в случае с SegmentAllocator.allocate(MemoryLayout)). Размер сегмента памяти обычно является положительным числом, но может быть равен нулю, однако никогда не бывает отрицательным.

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

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

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

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

Сегмент памяти можно читать и записывать с помощью различных операций доступа, предоставляемых этим классом (например, get(ValueLayout.OfInt, long)). Каждая операция доступа принимает раскладку значения value layout, задающую размер и форму значения, а также смещение, выраженное в байтах. Например, для чтения значения int из сегмента с использованием порядка байтов по умолчанию можно использовать следующий код:

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

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

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

Операции доступа к сегментам памяти реализованы с помощью var handle. Метод ValueLayout.varHandle() позволяет получить var handle, с помощью которого можно получать и задавать значения, представленные заданной раскладкой значения, в сегменте памяти по указанному смещению:

VarHandle intAtOffsetHandle = ValueLayout.JAVA_INT.varHandle(); // (MemorySegment, long)
int value = (int) intAtOffsetHandle.get(segment, 10L);          // segment.get(ValueLayout.JAVA_INT, 10L)

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

VarHandle intAtOffsetAndIndexHandle =
        ValueLayout.JAVA_INT.arrayElementVarHandle();             // (MemorySegment, long, long)
int value = (int) intAtOffsetAndIndexHandle.get(segment, 2L, 3L); // segment.get(ValueLayout.JAVA_INT, 2L + (3L * 4L))

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

VarHandle intAtIndexHandle =
        MethodHandles.insertCoordinates(intAtOffsetAndIndexHandle, 1, 0L); // (MemorySegment, long)
int value = (int) intAtIndexHandle.get(segment, 3L);                       // segment.getAtIndex(ValueLayout.JAVA_INT, 3L);

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

Создание срезов сегментов памяти

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

 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) или SegmentAllocator.allocate(MemoryLayout). Эти фабричные методы гарантируют, что начальный адрес области памяти вне кучи, в которой размещён возвращаемый сегмент, будет выровнен на 8 байт. После этого программист может обращаться к сегменту по нужным смещениям — 0, 8, 16, 24 и т. д. — зная, что каждое такое обращение будет выровнено.

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

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

Начальный физический адрес массива short[] будет выровнен на 2 байта (например, 1006), чтобы следующие друг за другом элементы short находились по адресам, выровненным на 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), чтобы следующие друг за другом элементы long находились по адресам, выровненным на 8 байт (например, 1000, 1008, 1016, 1024 и т. д.). К сегменту кучи, размещённому в массиве 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 байта.

Иными словами, для сегментов кучи предусмотрено максимальное выравнивание, которое определяется размером элементов массива 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(), то есть 8 байтам:

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) ограничение на выравнивание установлено равным 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()

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

MemoryLayout layout = ...
MemorySegment segment = ...
boolean isAligned = segment.maxByteAlignment() >= layout.byteAlignment();

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

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

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

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

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

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

Чтобы показать, как клиенты могут работать с сегментами памяти нулевой длины, рассмотрим случай, когда клиент хочет прочитать указатель из некоторого сегмента памяти. Это можно сделать с помощью метода доступа get(AddressLayout, long). Этот метод принимает раскладку адреса address layout (например, ValueLayout.ADDRESS) — раскладку указателя, который нужно прочитать. Например, на 64-разрядной платформе размер раскладки адреса равен 8 байтам. Операция доступа также принимает смещение, выраженное в байтах, которое указывает позицию (относительно начала сегмента памяти), в которой хранится указатель. Операция доступа возвращает нативный сегмент памяти нулевой длины, размещённый в области памяти, начальный адрес которой равен 64-разрядному значению, прочитанному по указанному смещению.

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

 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)^RESTRICTED, который возвращает новый нативный сегмент заданного размера с теми же временными границами, что и у указанной арены:

 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 = 16, scope = arena.scope()
       int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);            // ok
 }
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);                  // throws IllegalStateException

В качестве альтернативы, если размер области памяти, в которой размещён сегмент памяти нулевой длины, известен заранее, клиент может наложить целевую раскладку^RESTRICTED на раскладку адреса, используемую при чтении указателя. Затем целевая раскладка используется для динамического увеличения размера нативного сегмента памяти, возвращаемого операцией доступа, до размера целевой раскладки. Иными словами, возвращаемый сегмент больше не является сегментом памяти нулевой длины, и указатель, который он представляет, можно разыменовать напрямую:

 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)^RESTRICTED, reinterpret(Arena, Consumer)^RESTRICTED, reinterpret(long, Arena, Consumer)^RESTRICTED и AddressLayout.withTargetLayout(MemoryLayout)^RESTRICTED) являются методами с ограниченным доступом и должны использоваться с осторожностью: назначение сегменту неверных пространственных и/или временных границ может привести к сбою виртуальной машины при попытке доступа к сегменту памяти.

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

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

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

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

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

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

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

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

NULL

static final MemorySegment NULL

Нативный сегмент нулевой длины, моделирующий адрес NULL. Эквивалентен MemorySegment.ofAddress(0L).

Максимальное выравнивание по байтам для сегмента NULL составляет 2⁶².

Примечание API:: Клиентам следует избегать использования == для сравнения сегмента с MemorySegment.NULL. Сегмент с адресом 0L может быть создан независимо и поэтому может иметь другую идентичность.

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

address

long address()

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

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

heapBase

Optional<Object> heapBase()

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

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

spliterator

Spliterator<MemorySegment> spliterator(MemoryLayout 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<MemorySegment> elements(MemoryLayout 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.Scope scope()

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

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

isAccessibleBy

boolean isAccessibleBy(Thread thread)

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

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

byteSize

long byteSize()

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

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

maxByteAlignment

long maxByteAlignment()

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

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

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

MemoryLayout layout = ...
MemorySegment segment = ...
if (segment.maxByteAlignment() < layout.byteAlignment()) {
    // Take action (e.g. throw an Exception)
}

Возвращает:: максимальное выравнивание по байтам, связанное с этим сегментом памяти
Начиная с:: 23

asSlice

MemorySegment asSlice(long offset, long newSize)

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

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

asSlice(offset, newSize, 1);

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

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

Параметры:

offset — новое базовое смещение сегмента относительно адреса этого сегмента, заданное в байтах

newSize — новый размер сегмента, заданный в байтах

Возвращает:

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

Исключения:

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

См. также:

asSlice

MemorySegment 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

MemorySegment asSlice(long offset, MemoryLayout layout)

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

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

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

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

Параметры:

offset — новое базовое смещение сегмента относительно адреса этого сегмента, заданное в байтах

layout — раскладка среза сегмента

Возвращает:

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

Исключения:

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

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

См. также:

asSlice

MemorySegment asSlice(long offset)

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

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

asSlice(offset, byteSize() - offset);

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

Параметры:

offset — новое базовое смещение сегмента относительно адреса этого сегмента, заданное в байтах

Возвращает:

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

Исключения:

IndexOutOfBoundsException — если offset < 0 или offset > byteSize()

См. также:

reinterpret

MemorySegment reinterpret(long newSize)

reinterpret — это ограниченный метод платформы Java.

Программы могут использовать reinterpret только при включенном доступе к ограниченным методам.

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

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

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

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

reinterpret

MemorySegment reinterpret(Arena arena, Consumer<MemorySegment> cleanup)

reinterpret — это ограниченный метод платформы Java.

Программы могут использовать reinterpret только при включенном доступе к ограниченным методам.

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

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

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

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

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

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

reinterpret

MemorySegment reinterpret(long newSize, Arena arena, Consumer<MemorySegment> cleanup)

reinterpret — это ограниченный метод платформы Java.

Программы могут использовать reinterpret только при включенном доступе к ограниченным методам.

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

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

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

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

isReadOnly

boolean isReadOnly()

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

Возвращает:

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

См. также:

asReadOnly

MemorySegment asReadOnly()

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

Возвращает:

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

См. также:

isNative

boolean isNative()

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

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

Возвращает:: true, если этот сегмент является нативным

isMapped

boolean isMapped()

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

Возвращает:: true, если этот сегмент является отображенным сегментом

asOverlappingSlice

Optional<MemorySegment> asOverlappingSlice(MemorySegment other)

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

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

Параметры:: other — сегмент, пересечение которого с этим сегментом нужно проверить
Возвращает:: срез этого сегмента (в области пересечения)

fill

MemorySegment fill(byte value)

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

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

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

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

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

Параметры:: value — значение, записываемое в этот сегмент
Возвращает:: этот сегмент памяти
Исключения:: IllegalStateException — если связанная с этим сегментом область действия не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException — если этот сегмент доступен только для чтения

copyFrom

MemorySegment copyFrom(MemorySegment src)

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

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

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

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

mismatch

long mismatch(MemorySegment other)

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

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

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

isLoaded

boolean isLoaded()

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

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

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

Возвращает:: true, если содержимое этого сегмента, вероятно, находится в физической памяти
Вызывает:: IllegalStateException — если область действия, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; UnsupportedOperationException — если этот сегмент не является отображённым сегментом памяти, например если isMapped() == false

load

void load()

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

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

Вызывает:: IllegalStateException — если область действия, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; UnsupportedOperationException — если этот сегмент не является отображённым сегментом памяти, например если isMapped() == false

unload

void unload()

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

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

Вызывает:: IllegalStateException — если область действия, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; UnsupportedOperationException — если этот сегмент не является отображённым сегментом памяти, например если isMapped() == false

force

void force()

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

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

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

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

Вызывает:: IllegalStateException — если область действия, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; UnsupportedOperationException — если этот сегмент не является отображённым сегментом памяти, например если isMapped() == false; UncheckedIOException — если при записи содержимого этого сегмента на связанное устройство хранения произошла ошибка ввода-вывода

asByteBuffer

ByteBuffer asByteBuffer()

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

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

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

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

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

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

toArray

byte[] toArray(ValueLayout.OfByte elementLayout)

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

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

toArray

short[] toArray(ValueLayout.OfShort elementLayout)

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

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

toArray

char[] toArray(ValueLayout.OfChar elementLayout)

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

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

toArray

int[] toArray(ValueLayout.OfInt elementLayout)

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

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

toArray

float[] toArray(ValueLayout.OfFloat elementLayout)

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

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

toArray

long[] toArray(ValueLayout.OfLong elementLayout)

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

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

toArray

double[] toArray(ValueLayout.OfDouble elementLayout)

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

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

getString

String getString(long offset)

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

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

 getString(offset, StandardCharsets.UTF_8);

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

getString

String getString(long offset, Charset charset)

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

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

Получить строку из сегмента, если известны смещение и длина в байтах, можно с помощью getString(long, Charset, long).

Параметры:: offset — смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена эта операция доступа; charset — кодировка, используемая для декодирования байтов строки. charset должна быть стандартной кодировкой
Возвращает:: строку Java, созданную из байтов, считанных по указанному начальному адресу до первого символа-терминатора '\0' (не включая его, если он найден)
Вызывает:: IllegalArgumentException — если размер строки превышает максимальный размер строки, поддерживаемый платформой; IndexOutOfBoundsException — если offset < 0; IndexOutOfBoundsException — если в этом сегменте между указанным offset и концом сегмента отсутствует терминатор строки (например, '\0'). Размер терминатора строки в байтах зависит от выбранной charset. Например, он равен 1 для StandardCharsets.US_ASCII и 2 для StandardCharsets.UTF_16; IllegalStateException — если область действия, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException — если charset не является стандартной кодировкой

getString

String getString(long offset, Charset charset, long byteLength)

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

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

Параметры:: offset — смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена эта операция доступа; charset — кодировка, используемая для декодирования байтов строки; byteLength — длина области памяти в байтах, которую необходимо прочитать и декодировать в строку
Возвращает:: строку Java, созданную из байтов, считанных по указанному начальному адресу в пределах заданной длины
Вызывает:: IllegalArgumentException — если размер строки превышает максимальный размер строки, поддерживаемый платформой; IndexOutOfBoundsException — если offset < 0; IndexOutOfBoundsException — если offset > byteSize() - byteLength; IllegalStateException — если область действия, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException — если byteLength < 0
Начиная с:: 27

setString

void setString(long offset, String str)

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

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

 setString(offset, str, StandardCharsets.UTF_8);

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

setString

void setString(long offset, String str, Charset charset)

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

Если указанная строка содержит символы '\0', они также будут скопированы. Это означает, что в зависимости от метода чтения строки, например getString(long), при повторном чтении строка будет усечена. Прочитать строку без усечения можно с помощью getString(long, Charset, long).

Параметры:

offset — смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена эта операция доступа; итоговый адрес операции записи можно выразить как address() + offset

str — строка Java, которую необходимо записать в этот сегмент

charset — кодировка, используемая для кодирования байтов строки. charset должна быть стандартной кодировкой

Вызывает:

IndexOutOfBoundsException — если offset < 0

IndexOutOfBoundsException — если offset > byteSize() - (B + N), где:

B — размер строки в байтах, закодированной с использованием заданной кодировки (например, str.getBytes(charset).length);
N — размер (в байтах) символа-терминатора в заданной кодировке. Например, он равен 1 для StandardCharsets.US_ASCII и 2 для StandardCharsets.UTF_16.

IllegalStateException — если область действия, связанная с этим сегментом, не является активной

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

IllegalArgumentException — если charset не является стандартной кодировкой

IllegalArgumentException — если этот сегмент доступен только для чтения

ofBuffer

static MemorySegment ofBuffer(Buffer buffer)

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

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

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

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

ofArray

static MemorySegment ofArray(byte[] byteArray)

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

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

ofArray

static MemorySegment ofArray(char[] charArray)

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

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

ofArray

static MemorySegment ofArray(short[] shortArray)

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

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

ofArray

static MemorySegment ofArray(int[] intArray)

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

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

ofArray

static MemorySegment ofArray(float[] floatArray)

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

Параметры:: floatArray — примитивный массив, на основе которого создан сегмент кучи
Возвращает:: сегмент памяти кучи, созданный на основе массива float

ofArray

static MemorySegment ofArray(long[] longArray)

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

Параметры:: longArray — примитивный массив, на основе которого создан сегмент кучи
Возвращает:: сегмент памяти кучи, созданный на основе массива long

ofArray

static MemorySegment ofArray(double[] doubleArray)

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

Параметры:: doubleArray — примитивный массив, на основе которого создан сегмент кучи
Возвращает:: сегмент памяти кучи, созданный на основе массива double

ofAddress

static MemorySegment ofAddress(long address)

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

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

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

Параметры:: address — адрес возвращенного сегмента нативной памяти
Возвращает:: сегмент нативной памяти нулевой длины с указанным адресом

copy

static void copy(MemorySegment srcSegment, long srcOffset, MemorySegment 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);

Параметры:: srcSegment — исходный сегмент; srcOffset — начальное смещение в байтах в исходном сегменте; dstSegment — целевой сегмент; dstOffset — начальное смещение в байтах в целевом сегменте; bytes — количество байтов для копирования
Вызывает исключение:: IllegalStateException — если связанная с srcSegment область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что srcSegment.isAccessibleBy(T) == false; IllegalStateException — если связанная с dstSegment область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что dstSegment.isAccessibleBy(T) == false; IndexOutOfBoundsException — если srcOffset > srcSegment.byteSize() - bytes; IndexOutOfBoundsException — если dstOffset > dstSegment.byteSize() - bytes; IndexOutOfBoundsException — если srcOffset, dstOffset или bytes являются < 0; IllegalArgumentException — если dstSegment доступен только для чтения

copy

static void copy(MemorySegment srcSegment, ValueLayout srcElementLayout, long srcOffset, MemorySegment dstSegment, ValueLayout 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.

Параметры:: srcSegment — исходный сегмент; srcElementLayout — макет элемента, связанный с исходным сегментом; srcOffset — начальное смещение в байтах в исходном сегменте; dstSegment — целевой сегмент; dstElementLayout — макет элемента, связанный с целевым сегментом; dstOffset — начальное смещение в байтах в целевом сегменте; elementCount — количество элементов для копирования
Вызывает исключение:: IllegalArgumentException — если размеры макетов элементов различаются или сегмент/смещение источника (соответственно, назначения) несовместимы с ограничением выравнивания в макете элемента источника (соответственно, назначения); IllegalArgumentException — если srcElementLayout.byteAlignment() > srcElementLayout.byteSize(); IllegalArgumentException — если dstElementLayout.byteAlignment() > dstElementLayout.byteSize(); IllegalStateException — если связанная с srcSegment область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что srcSegment.isAccessibleBy(T) == false; IllegalStateException — если связанная с dstSegment область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что dstSegment.isAccessibleBy(T) == false; IllegalArgumentException — если dstSegment доступен только для чтения; IndexOutOfBoundsException — если происходит переполнение elementCount * srcLayout.byteSize(); IndexOutOfBoundsException — если происходит переполнение elementCount * dtsLayout.byteSize(); IndexOutOfBoundsException — если srcOffset > srcSegment.byteSize() - (elementCount * srcLayout.byteSize()); IndexOutOfBoundsException — если dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize()); IndexOutOfBoundsException — если srcOffset, dstOffset или elementCount являются < 0

get

byte get(ValueLayout.OfByte layout, long offset)

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

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.
Возвращает:: значение byte, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.; value — записываемое значение byte.
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

boolean get(ValueLayout.OfBoolean layout, long offset)

Читает значение boolean из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа
Возвращает:: значение boolean, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа; value — записываемое значение boolean
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

char get(ValueLayout.OfChar layout, long offset)

Читает значение char из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа
Возвращает:: значение char, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.; value — записываемое значение char
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

short get(ValueLayout.OfShort layout, long offset)

Читает значение short из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа
Возвращает:: значение short, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.; value — записываемое значение short
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

int get(ValueLayout.OfInt layout, long offset)

Читает значение int из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.
Возвращает:: значение int, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа; value — записываемое значение int
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

float get(ValueLayout.OfFloat layout, long offset)

Читает значение float из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа
Возвращает:: значение float, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа; value — записываемое значение float
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

long get(ValueLayout.OfLong layout, long offset)

Читает значение long из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.
Возвращает:: значение long, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

void set(ValueLayout.OfLong layout, long offset, long value)

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа.; value — записываемое значение long.
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

double get(ValueLayout.OfDouble layout, long offset)

Читает значение double из этого сегмента по указанному смещению, используя заданный макет.

Параметры:: layout — макет области памяти, из которой выполняется чтение; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа
Возвращает:: значение double, прочитанное из этого сегмента
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

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

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

Параметры:: layout — макет области памяти, в которую выполняется запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому выполняется операция доступа; value — записываемое значение double
Вызывает исключение:: IllegalStateException — если связанная с этим сегментом область действия не активна; WrongThreadException — если этот метод вызван из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в указанном макете; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если этот сегмент доступен только для чтения

get

MemorySegment get(AddressLayout layout, long offset)

Читает адрес из этого сегмента по заданному смещению с использованием заданного layout. Прочитанный адрес оборачивается в нативный сегмент, связанный с глобальной областью видимости. В обычных условиях размер возвращаемого сегмента равен 0. Однако если предоставленный layout адреса имеет целевой layout T, размер возвращаемого сегмента устанавливается равным T.byteSize().

Параметры:: layout — layout области памяти, которую необходимо прочитать; offset — смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена эта операция доступа
Возвращает:: нативный сегмент, оборачивающий адрес, прочитанный из этого сегмента
Выбрасывает:: IllegalStateException — если область видимости, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IllegalArgumentException — если предоставленный layout адреса имеет целевой layout T, а адрес возвращаемого сегмента несовместим с ограничением выравнивания в T; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0

set

void set(AddressLayout layout, long offset, MemorySegment value)

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

Параметры:: layout — layout области памяти, в которую необходимо выполнить запись; offset — смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена эта операция доступа.; value — записываемое значение адреса.
Выбрасывает:: IllegalStateException — если область видимости, связанная с этим сегментом, не является активной; WrongThreadException — если этот метод вызван из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException — если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IndexOutOfBoundsException — если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException — если value не является нативным сегментом; IllegalArgumentException — если этот сегмент доступен только для чтения

getAtIndex

byte getAtIndex(ValueLayout.OfByte layout, long index)

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

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

getAtIndex

boolean getAtIndex(ValueLayout.OfBoolean layout, long index)

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

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

getAtIndex

char getAtIndex(ValueLayout.OfChar layout, long index)

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

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

setAtIndex

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

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

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

getAtIndex

short getAtIndex(ValueLayout.OfShort layout, long index)

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

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

setAtIndex

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

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

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

setAtIndex

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

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

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

setAtIndex

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

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

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

getAtIndex

int getAtIndex(ValueLayout.OfInt layout, long index)

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

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

setAtIndex

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

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

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

getAtIndex

float getAtIndex(ValueLayout.OfFloat layout, long index)

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

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

setAtIndex

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

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

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

getAtIndex

long getAtIndex(ValueLayout.OfLong layout, long index)

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

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

setAtIndex

void setAtIndex(ValueLayout.OfLong layout, long index, long value)

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

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

getAtIndex

double getAtIndex(ValueLayout.OfDouble layout, long index)

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

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

setAtIndex

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

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

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

getAtIndex

MemorySegment getAtIndex(AddressLayout layout, long index)

Читает адрес из этого сегмента по заданному индексу, масштабированному на размер заданного layout. Прочитанный адрес оборачивается в нативный сегмент, связанный с глобальной областью видимости. В обычных условиях размер возвращаемого сегмента равен 0. Однако если предоставленный layout адреса имеет целевой layout T, размер возвращаемого сегмента устанавливается равным T.byteSize().

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

setAtIndex

void setAtIndex(AddressLayout layout, long index, MemorySegment value)

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

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

equals

boolean equals(Object that)

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

Точнее, чтобы два сегмента s1 и s2 считались равными, должны выполняться все следующие условия:

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

Переопределяет:

equals в классе Object

Примечание API:

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

Параметры:

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

Возвращает:

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

См. также:

hashCode

int hashCode()

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

Переопределяет:

hashCode в классе Object

Возвращает:

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

См. также:

copy

static void copy(MemorySegment srcSegment, ValueLayout srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)

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

Поддерживаются следующие типы массивов: byte[], char[], short[], int[], float[], long[] и double[].

Параметры:: srcSegment — исходный сегмент; srcLayout — макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от порядка байтов платформы, для каждого элемента массива выполняется операция перестановки байтов; srcOffset — начальное смещение исходного сегмента в байтах; dstArray — массив назначения; dstIndex — начальный индекс массива назначения; elementCount — количество копируемых элементов массива
Выбрасывает:: 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

copy

static void copy(Object srcArray, int srcIndex, MemorySegment dstSegment, ValueLayout 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(); IllegalArgumentException — если dstSegment доступен только для чтения; IndexOutOfBoundsException — если происходит переполнение elementCount * dstLayout.byteSize(); IndexOutOfBoundsException — если dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize()); IndexOutOfBoundsException — если srcIndex > srcArray.length - elementCount; IndexOutOfBoundsException — если srcIndex, dstOffset или elementCount являются < 0

copy

static long copy(String src, Charset dstEncoding, int srcIndex, MemorySegment dst, long dstOffset, int numChars)

Копирует последовательность байтов заданной строки, закодированной с использованием указанной кодировки, в целевой сегмент.

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

Если заданная строка содержит символы '\0', они также будут скопированы. Это означает, что в зависимости от метода чтения строки, например getString(long), при повторном чтении строка будет усечена. Строку можно прочитать без усечения с помощью getString(long, Charset, long).

Параметры:: src — строка Java, записываемая в целевой сегмент; dstEncoding — кодировка, используемая для кодирования байтов строки.; srcIndex — начальный индекс символа исходной строки; dst — целевой сегмент; dstOffset — начальное смещение целевого сегмента в байтах; numChars — количество копируемых символов
Возвращает:: количество скопированных байтов.
Выбрасывает:: IllegalStateException — если область действия, связанная с dst, не активна; WrongThreadException — если этот метод вызван из потока T, такого что dst.isAccessibleBy(T) == false; IndexOutOfBoundsException — если srcIndex, numChars или dstOffset являются < 0; IndexOutOfBoundsException — если srcIndex > src.length() - numChars; IllegalArgumentException — если dst доступен только для чтения; IndexOutOfBoundsException — если dstOffset > dstSegment.byteSize() - B, где B — размер в байтах подстроки src, закодированной с использованием указанной кодировки
Начиная с:: 27

mismatch

static long mismatch(MemorySegment srcSegment, long srcFromOffset, long srcToOffset, MemorySegment 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, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.