public sealed interface MemorySegment

MemorySegmentは、JavaプラットフォームのプレビューAPIです。

プレビュー機能が有効な場合のみ、プログラムでMemorySegmentを使用できます。

プレビュー機能は、今後のリリースで削除するか、Javaプラットフォームの永続機能にアップグレードすることができます。

メモリー・セグメントは、メモリーの連続したリージョンへのアクセスを提供します。

メモリー・セグメントには、次の2種類があります:

「ヒープ・セグメント」は、Javaヒープ("on-heap"リージョン)内のメモリー・リージョンによってバックアップされ、アクセスを提供します。
「ネイティブ・セグメント」は、Javaヒープ("off-heap"リージョン)の外部にあるメモリーのリージョンによってバックアップされ、アクセスを提供します。

ヒープ・セグメントは、ofArray(int[])ファクトリ・メソッドのいずれかをコールすることで取得できます。これらのメソッドは、指定されたJava配列を保持するオン・ヒープ・リージョンによって支えられたメモリー・セグメントを返します。

ネイティブ・セグメントを取得するには、Arena.allocate(long, long)^PREVIEWファクトリ・メソッドのいずれかを呼び出します。これにより、指定されたサイズで新しく割り当てられたオフ・ヒープ・リージョンによって支えられたメモリー・セグメントが、指定された整列制約に整列されます。または、ネイティブ・セグメントは、ファイルをmapping^PREVIEWで新しいオフ・ヒープ・リージョン(一部のシステムでは、この操作をmmapと呼びます)に取得できます。この方法で取得されたセグメントは、「マップ済」セグメントと呼ばれ、その内容は、基礎となるメモリー・マップ・ファイルとの間で「存続」および「読み込み完了」になります。

どちらの種類のセグメントも、同じメソッド(「アクセス操作」)を使用して読取りおよび書込みが行われます。メモリー・セグメントに対するアクセス操作は常に行われ、セグメントが取得されたリージョンにのみアクセスできます。

メモリー・セグメントの特性

すべてのメモリー・セグメントには、long値として表されるaddressがあります。セグメントの住所の性質は、セグメントの種類によって異なります:

ヒープ・セグメントのアドレスは物理アドレスではなく、セグメントを支えるメモリー・リージョン内のオフセットです。リージョンはJavaヒープ内にあるため、ガベージ・コレクションによってリージョンが時間とともに物理メモリーに再配置される可能性がありますが、これは、リージョンによってバックアップされたヒープ・セグメントの安定した「仮想化」アドレスを参照するMemorySegment APIのクライアントには公開されません。 ofArray(int[])ファクトリ・メソッドのいずれかから取得されたヒープ・セグメントのアドレスはゼロです。
ネイティブ・セグメント(マップされたセグメントを含む)のアドレスは、セグメントをバックするメモリー・リージョンの物理アドレスを示します。

すべてのメモリー・セグメントにsizeがあります。ヒープ・セグメントのサイズは、取得元のJava配列から導出されます。このサイズは、Javaランタイム全体で予測できます。ネイティブ・セグメントのサイズは、明示的に(Arena.allocate(long, long)^PREVIEWのように)に渡されるか、MemoryLayout^PREVIEW (SegmentAllocator.allocate(MemoryLayout)^PREVIEWのように)から導出されます。通常、メモリー・セグメントのサイズは正の数ですが、zeroですが、負の数にはなりません。

メモリー・セグメントのアドレスとサイズは、セグメントに対するアクセス操作が、セグメントを支えるメモリー・リージョンの境界を「外部」に下回らないように共同で保証します。つまり、メモリー・セグメントには「空間境界」があります。

すべてのメモリー・セグメントは、scope^PREVIEWに関連付けられます。これにより、メモリー・セグメントをバックするメモリー・リージョンが使用できなくなった場合、メモリー・セグメントに対するアクセス操作は実行できなくなります。(例:アクセスされたメモリー・セグメントに関連付けられたスコープがalive^PREVIEWではなくなった場合)。つまり、メモリー・セグメントには「一時的な境界」があります。

最後に、メモリー・セグメントに対するアクセス操作は、追加のスレッド競合チェックの対象になることがあります。ヒープ・セグメントには、どのスレッドからでもアクセスできます。逆に、ネイティブ・セグメントには、その取得に使用されるアリーナの「監禁特性」と互換してのみアクセスできます。

メモリー・セグメントへのアクセス

メモリー・セグメントは、このクラス(e.g. get(ValueLayout.OfInt, long))で提供される様々なアクセス操作を使用して読取りまたは書込みができます。各アクセス操作では、「値レイアウト」^PREVIEWが使用され、値のサイズとシェイプ、およびオフセットがバイト単位で指定されます。たとえば、「デフォルトのエンディアン」を使用してセグメントからintを読み取るには、次のコードを使用できます:

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

読み取る値がbig-endianエンコーディングを使用してメモリーに格納されている場合、アクセス操作は次のように表すことができます:

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

より複雑なアクセス操作(e.g.構造化メモリー・アクセス)の場合、クライアントはセグメントとlongオフセットを受け入れる「varハンドル」^PREVIEWを取得できます。 MethodHandlesクラスで定義されたvarハンドル・コンビネータ関数を使用してセグメントvarハンドル・ビューを適応させることで、より複雑なvarハンドルを取得できます:

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

または、メモリー・レイアウト^PREVIEWから複雑なvarハンドルを取得するには、次のようにレイアウト・パスを指定します:

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

メモリー・セグメントのスライス

メモリー・セグメントは「スライス」をサポートしています。メモリー・セグメントをスライスすると、元のメモリーと同じリージョンにバックアップされた新しいメモリー・セグメントが返されます。スライスされたセグメントのアドレスは、オフセット(バイトで表されます)を追加して、元のセグメントのアドレスから導出されます。スライスされたセグメントのサイズは、暗黙的に(元のセグメントのサイズから指定されたオフセットを減算)に導出されるか、明示的に指定されます。つまり、スライスされたセグメントには、元のセグメントのものよりも「どもり」の空間境界があります:

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

前述のコードでは、長さが100バイトのネイティブ・セグメントが作成され、segmentのオフセット50から始まり、長さが10バイトのスライスが作成されます。つまり、sliceのアドレスはsegment.address() + 50で、サイズは10です。その結果、sliceセグメントのオフセット20でint値を読み取ろうとすると例外が発生します。元のセグメントの「一時的な境界」^PREVIEWはそのスライスによって継承されます。つまり、segmentに関連付けられたスコープがalive^PREVIEWではなくなった場合、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を使用した「不可分アクセス操作」操作は、整列されたアドレスでのみ許可されます。また、連携は、アクセスされるセグメントがネイティブ・セグメントかヒープ・セグメントかに関係なく、アクセス操作に適用されます。

アクセスされるセグメントがネイティブ・セグメントである場合、物理メモリー内のそのaddressをオフセットと組み合せて、物理メモリー内の「ターゲット・アドレス」を取得できます。次の擬似関数では、次のようになります:

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

たとえば、

アドレス1000のネイティブ・セグメントには、8バイトの境界整列制約の下にあるオフセット0、8、16、24などでアクセスできます。これは、ターゲット・アドレス (1000, 1008, 1016, 1024)が8バイト境界整列されているためです。ターゲット・アドレスは8バイト境界整列されないため、オフセット1-7、9-15、または17-23でのアクセスは許可されません。
アドレス1000のネイティブ・セグメントには、4バイトの境界整列制約の下にあるオフセット0、4、8、12などでアクセスできます。これは、ターゲット・アドレス (1000, 1004, 1008, 1012)が4バイト境界整列されているためです。ターゲット・アドレスは4バイト境界整列されないため、オフセット1-3、5-7、または9-11でのアクセスは許可されません。
アドレス1000のネイティブ・セグメントは、ターゲット・アドレス (1000, 1002, 1004, 1006)が2バイト境界整列されているため、オフセット0、2、4、6などで2バイト境界整列制約の下でアクセスできます。ターゲット・アドレスは2バイト境界整列されないため、オフセット1、3、または5でのアクセスは許可されません。
アドレス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バイトの値のシーケンスを格納する場合は、Arena.allocate(long, long)^PREVIEWまたはSegmentAllocator.allocate(MemoryLayout)^PREVIEWのいずれかを使用して、8バイトの整列制約を指定してセグメントを割り当てる必要があります。これらのファクトリは、返されるセグメントを裏付けるメモリーのオフ・ヒープ・リージョンに、8バイトの整列された開始アドレスがあることを確認します。その後、プログラマは関心のある相殺でセグメントにアクセスできます -- 0、8、16、24など -- そのようなすべてのアクセスが合致しているという知識。

アクセスされるセグメントがヒープ・セグメントである場合、アクセスが整列されているかどうかの判断はより複雑です。物理メモリー内のセグメントのアドレスは不明であり、(ガベージ・コレクション中にセグメントが再配置されると変更される場合があります)も修正されていません。これは、物理メモリー内のターゲット・アドレスを特定するために、指定されたオフセットとアドレスを組み合わせることができないことを意味します。境界整列制約alwaysは物理メモリー内のアドレスの境界整列を指しているため、ヒープ・セグメント内のオフセットが整列されているかどうかは原則的に判断できません。たとえば、プログラマが8バイトの境界整列制約を選択し、ヒープ・セグメントのオフセット16にアクセスしようとするとします。ヒープ・セグメントのアドレス0が物理アドレス1000に対応している場合、ターゲット・アドレス (1016)は整列されますが、アドレス0が物理アドレス1004に対応している場合、ターゲット・アドレス (1020)は整列されません。プログラマが選択した境界整列制約に従って整列されているターゲット・アドレスへのアクセスを許可することは望ましくありませんが、物理メモリー (例:プラットフォームの考慮事項やガベージ・コレクションの動作など)で予測どおりに整列されない可能性があります。

実際には、Javaランタイムは、各nバイト要素がnバイト整列された物理アドレス(long[]とdouble[]を除き、ここで整列はプラットフォームに依存します(後述の説明を参照))で発生するように、配列をメモリー内に配置します。ランタイムは、ガベージ・コレクション中に配列が再配置された場合でも、この不変条件を保持します。アクセス操作は、ヒープ・セグメント内の指定されたオフセットが物理メモリー内の整列されたアドレスを参照しているかどうかを判定するために、この不変条件に依存します。たとえば、

short[]配列の開始物理アドレスは、2バイトに整列された(e.g. 1006)になるため、2バイトに整列されたアドレス(例: 1006、1008、1010、1012など)で連続する短い要素が発生します。 short[]配列によって支えられたヒープ・セグメントには、オフセット0、2、4、6などで2バイトの境界整列制約の下でアクセスできます。 4バイトの境界整列制約下にあるどのオフセットでもセグメントにアクセスすることはできません。ターゲット・アドレスが4バイト境界整列される保証はないためです。たとえば、オフセット0は物理アドレス1006に対応し、オフセット1は物理アドレス1007に対応します。同様に、ターゲット・アドレスが8バイト境界整列されるという保証がないため、8バイト境界整列制約の下にあるオフセットでセグメントにアクセスすることはできません。たとえば、オフセット2は物理アドレス1008に対応しますが、オフセット4は物理アドレス1010に対応します。
long[]配列の開始物理アドレスは、64ビット・プラットフォームでは8バイトの境界整列 (e.g. 1000)になるため、連続する長い要素が8バイト境界整列アドレスで発生します (e.g., 1000, 1008, 1016, 1024, etc.) 64ビット・プラットフォームでは、long[]配列に支えられたヒープ・セグメントに、8バイト境界整列制約の下にあるオフセット0、8、16、24などでアクセスできます。また、ターゲット・アドレス (1000, 1004, 1008, 1012)が4バイト境界整列されているため、4バイト境界整列制約の下でオフセット0、4、8、12などでセグメントにアクセスできます。また、ターゲット・アドレス (e.g. 1000, 1002, 1004, 1006)が2バイト境界整列されているため、2バイト境界整列制約の下でオフセット0、2、4、6などでセグメントにアクセスできます。
long[]配列の開始物理アドレスは、32ビット・プラットフォームでは4バイトに整列された (e.g. 1004)になるため、連続する長い要素が4バイトに整列されたアドレスで発生するようになります (e.g., 1004, 1008, 1012, 1016, etc.) 32ビット・プラットフォームでは、ターゲット・アドレス (1004, 1008, 1012, 1016)が4バイトに整列されるため、long[]配列によって支えられたヒープ・セグメントは、オフセット0、4、8、12などで4バイト境界整列制約の下でアクセスできます。また、ターゲット・アドレス (e.g. 1000, 1002, 1004, 1006)が2バイト境界整列されているため、2バイト境界整列制約の下でオフセット0、2、4、6などでセグメントにアクセスできます。

つまり、ヒープ・セグメントには、次の表に示すように、セグメントを支えるJava配列の要素のサイズから導出される(platform-dependent) maximumの整列があります:

ヒープ・セグメントの最大整列

配列タイプ(バッキング・リージョン) サポートされる最大アライメント (バイト単位)

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()

このような場合、クライアントには2つのオプションがあります。異なる配列タイプ(e.g. long[])に支えられたヒープ・セグメントを使用すると、最大長の整列をサポートできます。具体的には、long[]に関連付けられた最大整列は、プラットフォーム依存の値(ValueLayout.ADDRESS.byteSize()に設定)であるValueLayout.JAVA_LONG.byteAlignment()に設定されます。つまり、long[]は、64ビット・プラットフォームでは少なくとも8バイトの境界整列を提供することが保証されていますが、32ビット・プラットフォームでは4バイトの境界整列のみが提供されます:

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

または、「整列されていないレイアウト」を使用してアクセス操作を起動できます。すべての未整列レイアウト定数(e.g. ValueLayout.JAVA_INT_UNALIGNED^PREVIEW)の整列制約は1に設定されています:

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

長さゼロのメモリー・セグメント

「外部関数」と対話する場合は、これらの関数がメモリー・リージョンを割り当て、そのリージョンへのポインタを返すことが一般的です。 Javaランタイムはリージョンのサイズを把握できないため、メモリー・セグメントを使用してメモリー領域をモデリングすることは困難です。ポインタに格納されている、リージョンの先頭のアドレスのみを使用できます。たとえば、戻り型がchar*のC関数は、単一のchar値を含むリージョン、または配列のサイズを別々のパラメータに指定できるchar値の配列を含むリージョンへのポインタを返す場合があります。配列のサイズは、外部関数をコールするコードにすぐには見えず、その結果を使用します。外部関数から返されたポインタをバッキングするメモリーのリージョンのサイズに関するインサイトがないことに加えて、それを割り当てた外部関数によるメモリーの当該領域に対する有効期間に関するインサイトもありません。

MemorySegment APIでは、「長さゼロのメモリー・セグメント」を使用して次のものを表します:

「外部関数から戻される」ポインタ;
「外部関数によってアップコール・スタブに渡される」ポインタ;および
メモリー・セグメント (その下の詳細)から読み取られるポインタ。

長さゼロのセグメントのアドレスは、ポインタに格納されているアドレスです。長さゼロのセグメントの空間的境界と時間的境界は次のとおりです:

セグメントのサイズはゼロです。これらのセグメントにアクセスしようとすると、IndexOutOfBoundsExceptionで失敗します。これは重要な安全機能です: これらのセグメントは、サイズが不明なメモリー・リージョンに関連付けられているため、これらのセグメントに関連するアクセス操作は検証できません。実際には、長さゼロのメモリー・セグメントはアドレスを「ラップ」し、明示的なインテント(下記参照)がないと使用できません
セグメントは、常に有効である新しいスコープに関連付けられます。したがって、長さゼロのメモリー・セグメントには直接アクセスできませんが、外部関数を受け入れるほかのポインタに誤って渡すことができます。

クライアントが長さがゼロのメモリー・セグメントでどのように機能するかを示すために、一部のメモリー・セグメントからポインタを読み取るクライアントの場合について考えてみます。これは、get(AddressLayout, long)アクセス・メソッドを介して実行できます。このメソッドは、読み取るポインタのレイアウトである「アドレス・レイアウト」^PREVIEW (e.g. ValueLayout.ADDRESS^PREVIEW)を受け入れます。たとえば、64ビット・プラットフォームでは、アドレス・レイアウトのサイズは8バイトです。アクセス操作では、ポインタが格納される位置(メモリー・セグメントの先頭からの相対)を示すオフセット(バイト単位)も受け入れられます。アクセス操作は、長さがゼロのネイティブ・メモリー・セグメントを返します。このセグメントは、開始アドレスが、指定されたオフセットで読み取られた64ビット値であるメモリーのリージョンによって支えられます。

返された長さゼロのメモリー・セグメントには、クライアントから直接アクセスできません: セグメントのサイズがゼロであるため、アクセス操作によって範囲外アクセスが発生します。かわりに、クライアントは「不安」で、長さゼロのメモリー・セグメントに新しい空間境界を割り当てる必要があります。これは、次のようにreinterpret(long)メソッドを使用して実行できます:

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

場合によっては、クライアントは、新しい時間的境界を0長のメモリー・セグメントに割り当てることもできます。これは、reinterpret(long, Arena, Consumer)メソッドを使用して実行できます。このメソッドでは、指定されたアリーナと同じサイズおよび時間境界を持つ新しいネイティブ・セグメントが返されます:

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

または、長さゼロのメモリー・セグメントをバッキングするメモリー・リージョンのサイズが静的に認識されている場合、クライアントはポインタの読取り時に使用されるアドレス・レイアウトで「ターゲット・レイアウト」^PREVIEWをオーバーレイできます。次に、ターゲット・レイアウトを使用して、アクセス操作によって返されるネイティブ・メモリー・セグメントのサイズを動的に「拡張」し、セグメントのサイズがターゲット・レイアウトのサイズと同じになるようにします。つまり、返されるセグメントは長さがゼロのメモリー・セグメントではなくなり、それが表すポインタを直接参照解除できます:

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

長さゼロのメモリー・セグメント(reinterpret(long)、reinterpret(Arena, Consumer)、reinterpret(long, Arena, Consumer)およびAddressLayout.withTargetLayout(MemoryLayout)^PREVIEW)を操作するために使用できるすべてのメソッドは「制限付き」メソッドであり、注意して使用する必要があります: セグメントに不正な空間境界または時間境界(あるいはその両方)を割り当てると、メモリー・セグメントにアクセスしようとしたときにVMがクラッシュする可能性があります。

実装要件:: このインタフェースの実装は不変、スレッド・セーフ、およびvalue-basedです。
導入されたバージョン:: 19

ネストされたクラスのサマリー

ネストされたクラス

修飾子と型

インタフェース

説明

static interface

MemorySegment.Scope^PREVIEW

Preview.

スコープは、関連付けられているすべてのメモリー・セグメントのlifetimeをモデル化します。
フィールドのサマリー

フィールド

修飾子と型

フィールド

説明

static final MemorySegment^PREVIEW

NULL

NULLアドレスをモデリングする長さがゼロのネイティブ・セグメント。
メソッドのサマリー

修飾子と型

メソッド

説明

long

address()

このメモリー・セグメントのアドレスを返します。

ByteBuffer

asByteBuffer()

ByteBufferでこのセグメントをラップします。

Optional<MemorySegment^PREVIEW>

asOverlappingSlice(MemorySegment^PREVIEW other)

このセグメントと指定されたセグメントの間の重複である、このセグメントのスライスを返します。

MemorySegment^PREVIEW

asReadOnly()

このセグメントの読取り専用ビューを返します。

MemorySegment^PREVIEW

asSlice(long offset)

指定されたオフセットで、このメモリー・セグメントのスライスを返します。

MemorySegment^PREVIEW

asSlice(long offset, long newSize)

指定されたオフセットで、このメモリー・セグメントのスライスを返します。

MemorySegment^PREVIEW

asSlice(long offset, long newSize, long byteAlignment)

指定された境界整列制約を使用して、指定されたオフセットでこのメモリー・セグメントのスライスを返します。

default MemorySegment^PREVIEW

asSlice(long offset, MemoryLayout^PREVIEW layout)

指定されたレイアウトでこのメモリー・セグメントのスライスを、指定されたオフセットで返します。

long

byteSize()

このメモリー・セグメントのサイズ(バイト単位)を返します。

static void

copy(MemorySegment^PREVIEW srcSegment, long srcOffset, MemorySegment^PREVIEW dstSegment, long dstOffset, long bytes)

ソース・セグメントから宛先セグメントへの一括コピーを実行します。

static void

copy(MemorySegment^PREVIEW srcSegment, ValueLayout^PREVIEW srcElementLayout, long srcOffset, MemorySegment^PREVIEW dstSegment, ValueLayout^PREVIEW dstElementLayout, long dstOffset, long elementCount)

ソース・セグメントから宛先セグメントへの一括コピーを実行します。

static void

copy(MemorySegment^PREVIEW srcSegment, ValueLayout^PREVIEW srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)

ソース・メモリー・セグメントから宛先配列に多数の要素をコピーします。

static void

copy(Object srcArray, int srcIndex, MemorySegment^PREVIEW dstSegment, ValueLayout^PREVIEW dstLayout, long dstOffset, int elementCount)

ソース配列から宛先メモリー・セグメントに多数の要素をコピーします。

default MemorySegment^PREVIEW

copyFrom(MemorySegment^PREVIEW src)

指定されたソース・セグメントからこのセグメントへの一括コピーを実行します。

Stream<MemorySegment^PREVIEW>

elements(MemoryLayout^PREVIEW elementLayout)

このセグメント内の分離スライス(指定したレイアウトのサイズと一致するサイズ)に対して連続したStreamを返します。

boolean

equals(Object that)

指定されたオブジェクトをこのメモリー・セグメントと比較し、等しいかどうかを調べます。

MemorySegment^PREVIEW

fill(byte value)

このメモリー・セグメントの内容を指定された値で満たします。

void

force()

マップされたセグメント・ファイル記述子によって記述されたストレージ・デバイスに、このマップされたセグメントの内容に加えた変更を強制的に書き込みます。

default MemorySegment^PREVIEW

get(AddressLayout^PREVIEW layout, long offset)

指定されたレイアウトで、指定されたオフセットでこのセグメントからアドレスを読み取ります。

default boolean

get(ValueLayout.OfBoolean^PREVIEW layout, long offset)

指定されたオフセットを使用して、このセグメントからブールを読み取ります。

default byte

get(ValueLayout.OfByte^PREVIEW layout, long offset)

指定されたレイアウトで、指定されたオフセットでこのセグメントからバイトを読み取ります。

default char

get(ValueLayout.OfChar^PREVIEW layout, long offset)

指定されたレイアウトで、指定されたオフセットでこのセグメントからcharを読み取ります。

default double

get(ValueLayout.OfDouble^PREVIEW layout, long offset)

指定されたレイアウトで、指定されたオフセットでこのセグメントから倍精度浮動小数点数を読み取ります。

default float

get(ValueLayout.OfFloat^PREVIEW layout, long offset)

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからフロートを読み取ります。

default int

get(ValueLayout.OfInt^PREVIEW layout, long offset)

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからintを読み取ります。

default long

get(ValueLayout.OfLong^PREVIEW layout, long offset)

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからlongを読み取ります。

default short

get(ValueLayout.OfShort^PREVIEW layout, long offset)

指定されたレイアウトで、指定されたオフセットでこのセグメントからshortを読み取ります。

default MemorySegment^PREVIEW

getAtIndex(AddressLayout^PREVIEW layout, long index)

指定されたインデックスの指定されたセグメントからアドレスを読み取り、指定されたレイアウト・サイズでスケーリングします。

default boolean

getAtIndex(ValueLayout.OfBoolean^PREVIEW layout, long index)

指定されたインデックスのこのセグメントからブール値を読み取り、指定されたレイアウト・サイズでスケーリングします。

default byte

getAtIndex(ValueLayout.OfByte^PREVIEW layout, long index)

指定されたインデックスのこのセグメントからバイトを読み取り、指定されたレイアウト・サイズでスケーリングします。

default char

getAtIndex(ValueLayout.OfChar^PREVIEW layout, long index)

指定された索引のこのセグメントから、指定されたレイアウト・サイズで拡大縮小されたcharを読み取ります。

default double

getAtIndex(ValueLayout.OfDouble^PREVIEW layout, long index)

指定された索引で、指定されたレイアウト・サイズで倍精度浮動小数点数を読み取ります。

default float

getAtIndex(ValueLayout.OfFloat^PREVIEW layout, long index)

指定された索引のこのセグメントからフロートを読み取り、指定されたレイアウト・サイズでスケールします。

default int

getAtIndex(ValueLayout.OfInt^PREVIEW layout, long index)

指定されたレイアウト・サイズでスケールされた、指定された索引のこのセグメントからintを読み取ります。

default long

getAtIndex(ValueLayout.OfLong^PREVIEW layout, long index)

指定された索引でこのセグメントから、指定されたレイアウト・サイズでスケールされたlongを読み取ります。

default short

getAtIndex(ValueLayout.OfShort^PREVIEW layout, long index)

指定された索引のこのセグメントから、指定されたレイアウト・サイズでスケールされたshortを読み取ります。

default String

getUtf8String(long offset)

指定されたオフセットでこのセグメントからUTF-8エンコードされたNULL終了文字列を読み取ります。

int

hashCode()

このメモリー・セグメントのハッシュ・コード値を返します。

Optional<Object>

heapBase()

このメモリー・セグメントをバッキングするメモリーのオン・ヒープ・リージョンに格納されているJavaオブジェクト(ある場合)を返します。

boolean

isAccessibleBy(Thread thread)

指定されたスレッドからこのセグメントにアクセスできる場合は、trueを返します。

boolean

isLoaded()

このマップされたセグメントの内容が物理メモリーに存在するかどうかを決定します。

boolean

isMapped()

このセグメントがマップされたセグメントの場合は、trueを返します。

boolean

isNative()

このセグメントがネイティブ・セグメントの場合は、trueを返します。

boolean

isReadOnly()

このセグメントが読取り専用の場合、trueを返します。

void

load()

このマップされたセグメントの内容を物理メモリーにロードします。

default long

mismatch(MemorySegment^PREVIEW other)

このセグメントと指定された他のセグメントとの間で最初の不一致のオフセットをバイト単位で検索して返します。

static long

mismatch(MemorySegment^PREVIEW srcSegment, long srcFromOffset, long srcToOffset, MemorySegment^PREVIEW dstSegment, long dstFromOffset, long dstToOffset)

ソース・セグメントと宛先セグメント間の最初の不一致の相対オフセットをバイト単位で検索して返します。

static MemorySegment^PREVIEW

ofAddress(long address)

指定された「アドレス値」から長さゼロのネイティブ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(byte[] byteArray)

指定されたバイト配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(char[] charArray)

指定されたchar配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(double[] doubleArray)

指定された二重配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(float[] floatArray)

指定された浮動小数配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(int[] intArray)

指定されたint配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(long[] longArray)

指定された長い配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofArray(short[] shortArray)

指定された短い配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。

static MemorySegment^PREVIEW

ofBuffer(Buffer buffer)

指定されたBufferインスタンスをバックするメモリーの同じリージョンに基づくメモリー・セグメントを作成します。

MemorySegment^PREVIEW

reinterpret(long newSize)

このセグメントと同じアドレスとスコープを持つが、指定されたサイズの新しいメモリー・セグメントを返します。

MemorySegment^PREVIEW

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

このセグメントと同じアドレスで、指定されたサイズとスコープを持つ新しいセグメントを返します。

MemorySegment^PREVIEW

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

このセグメントと同じアドレスとサイズを持つが、指定されたスコープを持つ新しいメモリー・セグメントを返します。

MemorySegment.Scope^PREVIEW

scope()

このメモリー・セグメントに関連付けられたスコープを返します。

long

segmentOffset(MemorySegment^PREVIEW other)

このセグメントに対して指定されたセグメントのオフセット(バイト単位)を返します。

default void

set(AddressLayout^PREVIEW layout, long offset, MemorySegment^PREVIEW value)

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにアドレスを書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにブール値を書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにバイトを書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントに文字を書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにdoubleを書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにフロートを書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにintを書き込みます。

default void

set(ValueLayout.OfLong^PREVIEW layout, long offset, long value)

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにlongを書き込みます。

default void

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

指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにshortを書き込みます。

default void

setAtIndex(AddressLayout^PREVIEW layout, long index, MemorySegment^PREVIEW value)

指定された索引で、指定されたレイアウト・サイズでスケールされたアドレスをこのセグメントに書き込みます。

default void

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

指定されたインデックスのこのセグメントにブール値を書き込み、指定されたレイアウト・サイズでスケーリングします。

default void

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

指定されたインデックスのこのセグメントにバイトを書き込み、指定されたレイアウト・サイズでスケーリングします。

default void

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

指定された索引で、指定されたレイアウト・サイズでスケールされたcharをこのセグメントに書き込みます。

default void

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

指定された索引で、指定されたレイアウト・サイズでスケールされた倍精度浮動小数点数をこのセグメントに書き込みます。

default void

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

指定された索引でこのセグメントにフロートを書き込み、指定されたレイアウト・サイズでスケールします。

default void

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

指定された索引で、指定されたレイアウト・サイズでスケールされたintをこのセグメントに書き込みます。

default void

setAtIndex(ValueLayout.OfLong^PREVIEW layout, long index, long value)

指定された索引で、所定のレイアウト・サイズでスケールされたlongをこのセグメントに書き込みます。

default void

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

指定された索引で、指定されたレイアウト・サイズでスケールされたこのセグメントにshortを書き込みます。

default void

setUtf8String(long offset, String str)

指定された文字列を指定されたオフセットでこのセグメントに書き込み、UTF-8エンコーディングを使用してNULLで終了するバイト・シーケンスに変換します。

Spliterator<MemorySegment^PREVIEW>

spliterator(MemoryLayout^PREVIEW elementLayout)

このメモリー・セグメントのスプリッテレータを返します。

byte[]

toArray(ValueLayout.OfByte^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しいバイト配列にコピーします。

char[]

toArray(ValueLayout.OfChar^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しいchar配列にコピーします。

double[]

toArray(ValueLayout.OfDouble^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しい二重配列にコピーします。

float[]

toArray(ValueLayout.OfFloat^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しい浮動小数配列にコピーします。

int[]

toArray(ValueLayout.OfInt^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しいint配列にコピーします。

long[]

toArray(ValueLayout.OfLong^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しい長い配列にコピーします。

short[]

toArray(ValueLayout.OfShort^PREVIEW elementLayout)

このメモリー・セグメントの内容を新しい短い配列にコピーします。

void

unload()

このマップされたセグメントの内容を物理メモリーからアンロードします。

フィールド詳細
- NULL
  
  static final MemorySegment^PREVIEW NULL
  
  NULLアドレスをモデリングする長さがゼロのネイティブ・セグメント。
メソッドの詳細
- address
  
  long address()
  
  このメモリー・セグメントのアドレスを返します。
  
  APIのノート:
  
  このメソッドを使用してセグメント・アドレスを外部操作(例: JNI関数)に渡す場合、クライアントは、操作期間全体にわたってセグメントが「到達可能」に保持されていることを確認する必要があります。そのようにしないと、セグメントが「自動アリーナ」^PREVIEWで割り当てられている場合に、メモリー・セグメントをバッキングするメモリーのリージョンが途中で割当て解除される可能性があります。
  
  戻り値:
  
  このメモリー・セグメントのアドレス
- heapBase
  
  Optional<Object> heapBase()
  
  このメモリー・セグメントをバッキングするメモリーのオン・ヒープ・リージョンに格納されているJavaオブジェクト(ある場合)を返します。たとえば、このメモリー・セグメントがofArray(byte[])ファクトリ・メソッドで作成されたヒープ・セグメントである場合、このメソッドは、セグメントの取得に使用されたbyte[]オブジェクトを返します。このメソッドは、このセグメントが「ネイティブ」セグメントである場合、またはこのセグメントがread-onlyである場合、空のOptional値を返します。
  
  戻り値:
  
  このメモリー・セグメントに関連付けられているJavaオブジェクト(ある場合)。
- spliterator
  
  Spliterator<MemorySegment^PREVIEW> spliterator(MemoryLayout^PREVIEW 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^PREVIEW> elements(MemoryLayout^PREVIEW 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^PREVIEW scope()
  
  このメモリー・セグメントに関連付けられたスコープを返します。
  
  戻り値:
  
  このメモリー・セグメントに関連付けられたスコープ
- isAccessibleBy
  
  boolean isAccessibleBy(Thread thread)
  
  指定されたスレッドからこのセグメントにアクセスできる場合は、trueを返します。
  
  パラメータ:
  
  thread - テストするスレッド。
  
  戻り値:
  
  指定されたスレッドからこのセグメントにアクセスできる場合、true
- byteSize
  
  long byteSize()
  
  このメモリー・セグメントのサイズ(バイト単位)を返します。
  
  戻り値:
  
  このメモリー・セグメントのサイズ(バイト単位)
- asSlice
  
  MemorySegment^PREVIEW asSlice(long offset, long newSize)
  指定されたオフセットで、このメモリー・セグメントのスライスを返します。返されるセグメントのアドレスは、このセグメントのアドレスと指定されたオフセットです。そのサイズは、指定された引数で指定されます。
  次のコードと同等です:
  
  asSlice(offset, newSize, 1);
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(このセグメントのアドレスに対する相対)(バイト単位)です。
  
  newSize - 新しいセグメント・サイズ(バイト単位で指定)。
  
  戻り値:
  
  このメモリー・セグメントのスライス。
  
  例外:
  
  IndexOutOfBoundsException - offset < 0、offset > byteSize()、newSize < 0またはnewSize > byteSize() - offsetの場合
  
  関連項目:
  
  asSlice(long, long, long)
- asSlice
  
  MemorySegment^PREVIEW 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が2のべき乗でない場合。
- asSlice
  
  default MemorySegment^PREVIEW asSlice(long offset, MemoryLayout^PREVIEW layout)
  指定されたレイアウトでこのメモリー・セグメントのスライスを、指定されたオフセットで返します。返されるセグメントのアドレスは、このセグメントのアドレスと指定されたオフセットです。そのサイズは、指定されたレイアウトのサイズと同じです。
  次のコードと同等です:
  
  asSlice(offset, layout.byteSize(), layout.byteAlignment());
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(このセグメントのアドレスに対する相対)(バイト単位)です。
  
  layout - セグメント・スライスのレイアウト。
  
  戻り値:
  
  このメモリー・セグメントのスライス。
  
  例外:
  
  IndexOutOfBoundsException - offset < 0、offset > byteSize()またはlayout.byteSize() > byteSize() - offsetの場合
  
  IllegalArgumentException - このセグメントに、layoutで指定された境界整列制約の下にあるoffsetでアクセスできない場合。
  
  関連項目:
  
  asSlice(long, long, long)
- asSlice
  
  MemorySegment^PREVIEW asSlice(long offset)
  指定されたオフセットで、このメモリー・セグメントのスライスを返します。返されるセグメントのアドレスは、このセグメントのアドレスと指定されたオフセットの合計です。そのサイズは、このセグメント・サイズから指定されたオフセットを差し引いて計算されます。
  次のコードと同等です:
  
  asSlice(offset, byteSize() - offset);
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(このセグメントのアドレスに対する相対)(バイト単位)です。
  
  戻り値:
  
  このメモリー・セグメントのスライス。
  
  例外:
  
  IndexOutOfBoundsException - if offset < 0,またはoffset > byteSize()。
  
  関連項目:
  
  asSlice(long, long)
- reinterpret
  
  MemorySegment^PREVIEW reinterpret(long newSize)
  
  このセグメントと同じアドレスとスコープを持つが、指定されたサイズの新しいメモリー・セグメントを返します。
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  
  パラメータ:
  
  newSize - 返されるセグメントのサイズ。
  
  戻り値:
  
  このセグメントと同じアドレスとスコープを持つ新しいメモリー・セグメントですが、指定された新しいサイズです。
  
  例外:
  
  IllegalArgumentException - newSize < 0の場合。
  
  UnsupportedOperationException - このセグメントが「ネイティブ」セグメントでない場合。
  
  IllegalCallerException - 呼び出し元が、ネイティブ・アクセスが有効になっていないモジュール内にある場合。
- reinterpret
  
  MemorySegment^PREVIEW reinterpret(Arena^PREVIEW arena, Consumer<MemorySegment^PREVIEW> cleanup)
  このセグメントと同じアドレスとサイズを持つが、指定されたスコープを持つ新しいメモリー・セグメントを返します。そのため、返されたセグメントには、指定されたアリーナが閉じられたあとはアクセスできません。また、返されたセグメントには、指定されたアリーナに関連付けられた制限に準拠してアクセスできます: つまり、指定されたアリーナが「限定アリーナ」^PREVIEWの場合、返されるセグメントには、このセグメントに関連付けられた制限に関係なく、アリーナの所有者スレッドのみがアクセスできます。つまり、このメソッドは、指定されたアリーナを使用して割り当てられたかのように動作するセグメントを返します。
  クライアントは、指定されたスコープが無効になったときに実行する必要があるオプションのクリーンアップ・アクションを指定できます。このクリーンアップ・アクションは、このセグメントから取得された新しいメモリー・セグメントを次のように受け取ります:
  
  MemorySegment cleanupSegment = MemorySegment.ofAddress(this.address()) .reinterpret(byteSize());
  
  つまり、クリーン・アップ・アクションは、常に有効で、どのスレッドからもアクセスできる新しいスコープに関連付けられたセグメントを受け取ります。クリーンアップ・アクションによって受け入れられるセグメントのサイズは、byteSize()です。
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  APIのノート:
  
  クリーンアップ・アクション(存在する場合)では、メモリーのバッキング・リージョンが使用できなくなった後にセグメントにアクセスする可能性がある、受信したセグメントを外部クライアントにリークしないように注意してください。さらに、指定されたスコープが「自動アリーナ」^PREVIEWのスコープである場合、クリーンアップ・アクションによってスコープがunreachableになることを防ぐことはできません。失敗すると、自動アリーナによって割り当てられたメモリーのリージョンの割り当てが解除されなくなります。
  
  パラメータ:
  
  arena - 返されるセグメントに関連付けるアリーナ。
  
  cleanup - 指定されたアリーナが閉じられたときに実行されるクリーンアップ・アクション (nullにできます。)。
  
  戻り値:
  
  バインドされていないサイズの新しいメモリー・セグメント。
  
  例外:
  
  IllegalStateException - arena.scope().isAlive() == falseの場合。
  
  UnsupportedOperationException - このセグメントが「ネイティブ」セグメントでない場合。
  
  IllegalCallerException - 呼び出し元が、ネイティブ・アクセスが有効になっていないモジュール内にある場合。
- reinterpret
  
  MemorySegment^PREVIEW reinterpret(long newSize, Arena^PREVIEW arena, Consumer<MemorySegment^PREVIEW> cleanup)
  このセグメントと同じアドレスで、指定されたサイズとスコープを持つ新しいセグメントを返します。そのため、返されたセグメントには、指定されたアリーナが閉じられたあとはアクセスできません。さらに、返されたセグメントに、提供されたアリーナに関連付けられた制限に準拠してアクセスできる場合: つまり、指定されたアリーナが「限定アリーナ」^PREVIEWの場合、返されるセグメントには、このセグメントに関連付けられた制限に関係なく、アリーナの所有者スレッドのみがアクセスできます。つまり、このメソッドは、指定されたアリーナを使用して割り当てられたかのように動作するセグメントを返します。
  クライアントは、指定されたスコープが無効になったときに実行する必要があるオプションのクリーンアップ・アクションを指定できます。このクリーンアップ・アクションは、このセグメントから取得された新しいメモリー・セグメントを次のように受け取ります:
  
  MemorySegment cleanupSegment = MemorySegment.ofAddress(this.address()) .reinterpret(newSize);
  
  つまり、クリーン・アップ・アクションは、常に有効で、どのスレッドからもアクセスできる新しいスコープに関連付けられたセグメントを受け取ります。クリーンアップ・アクションによって受け入れられるセグメントのサイズは、newSizeです。
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  APIのノート:
  
  クリーンアップ・アクション(存在する場合)では、メモリーのバッキング・リージョンが使用できなくなった後にセグメントにアクセスする可能性がある、受信したセグメントを外部クライアントにリークしないように注意してください。さらに、指定されたスコープが「自動アリーナ」^PREVIEWのスコープである場合、クリーンアップ・アクションによってスコープがunreachableになることを防ぐことはできません。失敗すると、自動アリーナによって割り当てられたメモリーのリージョンの割り当てが解除されなくなります。
  
  パラメータ:
  
  newSize - 返されるセグメントのサイズ。
  
  arena - 返されるセグメントに関連付けるアリーナ。
  
  cleanup - 指定されたアリーナが閉じられたときに実行されるクリーンアップ・アクション (nullにできます。)。
  
  戻り値:
  
  このセグメントと同じアドレスを持つが、新しいサイズとそのスコープが指定のアリーナに設定されている新しいセグメント。
  
  例外:
  
  UnsupportedOperationException - このセグメントが「ネイティブ」セグメントでない場合。
  
  IllegalArgumentException - newSize < 0の場合。
  
  IllegalStateException - arena.scope().isAlive() == falseの場合。
  
  IllegalCallerException - 呼び出し元が、ネイティブ・アクセスが有効になっていないモジュール内にある場合。
- isReadOnly
  
  boolean isReadOnly()
  
  このセグメントが読取り専用の場合、trueを返します。
  戻り値:
  
  true:このセグメントが読取り専用の場合
  
  関連項目:
  
  asReadOnly()
- asReadOnly
  
  MemorySegment^PREVIEW asReadOnly()
  
  このセグメントの読取り専用ビューを返します。結果のセグメントはこのセグメントと同一になりますが、返されたセグメントの内容を上書きしようとすると、ランタイム例外が発生します。
  戻り値:
  
  このセグメントの読取り専用ビュー
  
  関連項目:
  
  isReadOnly()
- isNative
  
  boolean isNative()
  
  このセグメントがネイティブ・セグメントの場合は、trueを返します。ネイティブ・セグメントは、Arena.allocate(long, long)^PREVIEW (および関連)ファクトリ、または「ラッピング」によって「ダイレクト・バッファ」を使用して作成されます。
  
  戻り値:
  
  このセグメントがネイティブ・セグメントの場合はtrue。
- isMapped
  
  boolean isMapped()
  
  このセグメントがマップされたセグメントの場合は、trueを返します。マップされたメモリー・セグメントが作成されます(例: FileChannel.map(FileChannel.MapMode, long, long, Arena)^PREVIEWファクトリ、または「ラッピング」によって「マップされたバイト・バッファ」)。
  
  戻り値:
  
  このセグメントがマップされたセグメントである場合はtrue。
- asOverlappingSlice
  
  Optional<MemorySegment^PREVIEW> asOverlappingSlice(MemorySegment^PREVIEW other)
  
  このセグメントと指定されたセグメントの間の重複である、このセグメントのスライスを返します。
  同じメモリー・リージョンにバックアップされている2つ以上のスライスL1 (S1から)およびL2 (S2から)が見つかった場合は、2つのセグメントS1とS2が重複しているとみなされます。そのため、「ネイティブ」セグメントがヒープ・セグメントと重複することは不可能です。この場合、または重複が発生しない場合、空のOptionalが返されます。
  
  パラメータ:
  
  other - このセグメントとの重複をテストするセグメント。
  
  戻り値:
  
  このセグメント(重複が発生した場合)のスライス。
- segmentOffset
  
  long segmentOffset(MemorySegment^PREVIEW other)
  このセグメントに対して指定されたセグメントのオフセット(バイト単位)を返します。
  オフセットは、このセグメントのアドレスに対する相対値であり、負または正の値にすることができます。たとえば、両方のセグメントがネイティブ・セグメントであるか、同じ配列に支えられたヒープ・セグメントである場合、結果のオフセットは次のように計算できます:
  
  other.address() - address()
  
  セグメントが同じアドレスを共有している場合は、0が返されます。 otherがこのセグメントのスライスである場合、オフセットは常に0 <= x < this.byteSize()です。
  パラメータ:
  
  other - オフセットを取得するセグメント。
  
  戻り値:
  
  指定されたセグメントの相対オフセット(バイト単位)。
  
  例外:
  
  UnsupportedOperationException - 2つのセグメントを比較できない場合(例:異なる種類のセグメント、異なるJava配列によって裏付けられているセグメントなど)。
- fill
  
  MemorySegment^PREVIEW fill(byte value)
  このメモリー・セグメントの内容を指定された値で満たします。
  具体的には、指定された値はこのセグメントの各アドレスに書き込まれます。 (ただし、より効率的である可能性があります。)と同等のコードは次のとおりです:
  
  for (long offset = 0; offset < segment.byteSize(); offset++) { byteHandle.set(ValueLayout.JAVA_BYTE, offset, value); }
  
  ただし、設定されている特定のメモリー要素の順序については、考慮や保証はありません。
  このメソッドは、メモリー・セグメントの内容を初期化またはリセットする場合に役立ちます。
  パラメータ:
  
  value - このセグメントに書き込む値。
  
  戻り値:
  
  このメモリー・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- copyFrom
  
  default MemorySegment^PREVIEW copyFrom(MemorySegment^PREVIEW src)
  指定されたソース・セグメントからこのセグメントへの一括コピーを実行します。具体的には、ソース・セグメントのオフセット0からsrc.byteSize() - 1までのバイトは、src.byteSize() - 1を介したオフセット0でこのセグメントにコピーされます。
  このメソッドの呼出しは、次のコードと同じです:
  
  MemorySegment.copy(src, 0, this, 0, src.byteSize());
  パラメータ:
  
  src - ソース・セグメント。
  
  戻り値:
  
  このセグメント。
  
  例外:
  
  IndexOutOfBoundsException - src.byteSize() > this.byteSize()の場合。
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - srcに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(src.isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- mismatch
  
  default long mismatch(MemorySegment^PREVIEW other)
  
  このセグメントと指定された他のセグメントとの間で最初の不一致のオフセットをバイト単位で検索して返します。オフセットは、各セグメントのaddressに相対的になり、0 (inclusive)の範囲から、小さいメモリー・セグメント (exclusive)のsize (バイト単位)までの範囲になります。
  2つのセグメントが共通プリフィクスを共有している場合、返されるオフセットは共通プリフィクスの長さであり、それぞれのセグメント内のそのオフセットで2つのセグメント間に不一致があることが後続しています。 1つのセグメントがもう一方のセグメントの適切なプレフィクスである場合、返されるオフセットはセグメント・サイズの最小値であり、オフセットは大きいセグメントに対してのみ有効です。それ以外の場合、不一致はなく、 -1が返されます。
  
  パラメータ:
  
  other - このセグメントとの不一致をテストするセグメント。
  
  戻り値:
  
  このセグメントと指定されたほかのセグメントとの間で最初の不一致の相対オフセット(バイト単位)。一致しない場合は -1。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - otherに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(other.isAccessibleBy(T) == falseなど)。
- isLoaded
  
  boolean isLoaded()
  
  このマップされたセグメントの内容が物理メモリーに存在するかどうかを決定します。
  trueの戻り値は、このセグメント内のすべてのデータが物理メモリーに常駐している可能性が高いため、仮想メモリー・ページ・フォルトやI/O操作を行わずにアクセスできる可能性があることを意味します。戻り値のfalseは、このセグメント・コンテンツが物理メモリーに存在していないことを必ずしも意味しません。
  返される値は、保証ではなくヒントです。これは、基礎となるオペレーティング・システムが、このメソッドを呼び出したときにこのセグメント・データの一部をページアウトしたためです。
  
  戻り値:
  
  このセグメントの内容が物理メモリーに存在する可能性がある場合はtrue
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
- load
  
  void load()
  
  このマップされたセグメントの内容を物理メモリーにロードします。
  このメソッドを使用すると、このセグメントのこの内容が物理メモリーに常駐していることを確認できます。このメソッドを呼び出すと、ページ違反や入出力操作が発生する可能性があります。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
- unload
  
  void unload()
  
  このマップされたセグメントの内容を物理メモリーからアンロードします。
  このメソッドは、このセグメントのコンテンツが物理メモリーに存在しなくなるように最善の努力をします。このメソッドを呼び出した後にこのセグメントの内容にアクセスすると、いくつかのページ・フォルトおよびI/O操作が(このセグメント・コンテンツはページ・インする必要がある可能性があるため)に発生する可能性があります。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
- force
  
  void force()
  
  マップされたセグメント・ファイル記述子によって記述されたストレージ・デバイスに、このマップされたセグメントの内容に加えた変更を強制的に書き込みます。
  このマップされたセグメントに関連付けられているファイル記述子がローカル・ストレージ・デバイスに存在する場合、このメソッドが返すとき、このセグメントが作成されてからこのセグメントに加えられたすべての変更、またはこのメソッドが最後に呼び出されてから、そのデバイスに書き込まれていることが保証されます。
  このマップされたセグメントに関連付けられているファイル記述子がローカル・デバイスに存在しない場合は、そのような保証は行われません。
  このセグメントが読取り/書込みモードの(FileChannel.MapMode.READ_WRITE)でマップされていない場合、このメソッドを呼び出しても効果がない可能性があります。特に、このメソッドは、読取り専用またはプライベート・マッピング・モードでマップされたセグメントには影響しません。このメソッドは、実装固有のマッピング・モードに有効である場合も、そうでない場合もあります。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
  
  UncheckedIOException - このセグメントの内容を関連するストレージ・デバイスに書き込むI/Oエラーがある場合
- asByteBuffer
  
  ByteBuffer asByteBuffer()
  ByteBufferでこのセグメントをラップします。返されるバッファの一部のプロパティは、このセグメントのプロパティにリンクされます。具体的には、結果のバッファには次の特性があります:
  
  このセグメントが「読取り専用セグメント」の場合、read-onlyです
  
  「位置」はゼロに設定されます
  capacityとlimitは、どちらもこのセグメントのsizeに設定されます。このため、このセグメントのサイズがInteger.MAX_VALUEより大きい場合、バイト・バッファは返されません
  
  これがネイティブ・セグメントの場合、「ダイレクト・バッファ」です。
  
  返されるバッファのライフサイクルは、このセグメントのライフサイクルに関連付けられます。つまり、このセグメントに関連付けられたスコープがalive^PREVIEWではなくなった後に返されるバッファにアクセスすると、IllegalStateExceptionがスローされます。同様に、スレッドTから戻されたバッファにアクセスして、isAccessible(T) == falseがWrongThreadExceptionをスローするようにします。
  このセグメントが単一スレッドから「アクセシビリティ」である場合、結果として生成されるバッファで読取り/書込みI/O操作をコールすると、未指定の例外がスローされる可能性があります。このような問題のある操作の例として、AsynchronousSocketChannel.read(ByteBuffer)およびAsynchronousSocketChannel.write(ByteBuffer)があります。
  最後に、結果のバッファ・バイト順序はByteOrder.BIG_ENDIANです。これは、ByteBuffer.order(java.nio.ByteOrder)を使用して変更できます。
  戻り値:
  
  このメモリー・セグメントのByteBufferビュー。
  
  例外:
  
  UnsupportedOperationException - このセグメントをByteBufferインスタンスにマッピングできない場合(たとえば、byte[]以外の配列によってバックアップされたヒープ・セグメントの場合)、またはそのサイズがInteger.MAX_VALUEより大きい場合など)。
- toArray
  
  byte[] toArray(ValueLayout.OfByte^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しいバイト配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しいバイト配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメント・コンテンツをbyte[]インスタンスにコピーできない場合(サイズがInteger.MAX_VALUEより大きい場合など)。
- toArray
  
  short[] toArray(ValueLayout.OfShort^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい短い配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい短い配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメントの内容をshort[]インスタンスにコピーできない場合(例: byteSize() % 2 != 0、byteSize() / 2 > Integer.MAX_VALUE)
- toArray
  
  char[] toArray(ValueLayout.OfChar^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しいchar配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しいchar配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメントの内容をchar[]インスタンスにコピーできない場合(例: byteSize() % 2 != 0、byteSize() / 2 > Integer.MAX_VALUE)。
- toArray
  
  int[] toArray(ValueLayout.OfInt^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しいint配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しいint配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメントの内容をint[]インスタンスにコピーできない場合(例: byteSize() % 4 != 0、byteSize() / 4 > Integer.MAX_VALUE)。
- toArray
  
  float[] toArray(ValueLayout.OfFloat^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい浮動小数配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい浮動小数配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメントの内容をfloat[]インスタンスにコピーできない場合(例: byteSize() % 4 != 0、byteSize() / 4 > Integer.MAX_VALUE)。
- toArray
  
  long[] toArray(ValueLayout.OfLong^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい長い配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい長い配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメントの内容をlong[]インスタンスにコピーできない場合(例: byteSize() % 8 != 0、byteSize() / 8 > Integer.MAX_VALUE)。
- toArray
  
  double[] toArray(ValueLayout.OfDouble^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい二重配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい二重配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメントの内容をdouble[]インスタンスにコピーできない場合(例: byteSize() % 8 != 0、byteSize() / 8 > Integer.MAX_VALUE)。
- getUtf8String
  
  default String getUtf8String(long offset)
  
  指定されたオフセットでこのセグメントからUTF-8エンコードされたNULL終了文字列を読み取ります。
  このメソッドは、不正入力シーケンスやマップ不可文字シーケンスを、この文字セットのデフォルトの置換文字列で置き換えます。デコード処理をより強力に制御する必要がある場合、CharsetDecoderクラスを使用する必要があります。
  
  パラメータ:
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  指定された開始アドレスから読み取られたバイト数から、最初の'\0'終了文字(見つかったもの) (含まない)までのJava文字列。
  
  例外:
  
  IllegalArgumentException - UTF-8文字列のサイズがプラットフォームでサポートされる最大の文字列より大きい場合。
  
  IndexOutOfBoundsException - offset < 0またはoffset > byteSize() - Sの場合、SはUTF-8文字列(終端文字を含む)のサイズです。
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
- setUtf8String
  
  default void setUtf8String(long offset, String str)
  
  指定された文字列を指定されたオフセットでこのセグメントに書き込み、UTF-8エンコーディングを使用してNULLで終了するバイト・シーケンスに変換します。
  このメソッドは、不正入力シーケンスやマップ不可文字シーケンスを、この文字セットのデフォルトの置換文字列で置き換えます。デコード処理をより強力に制御する必要がある場合、CharsetDecoderクラスを使用する必要があります。
  指定された文字列に'\0'文字が含まれている場合、それらもコピーされます。つまり、文字列の読取りに使用されたメソッド(getUtf8String(long)など)に応じて、再度読み取るときに文字列が切り捨てられます。
  
  パラメータ:
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。この書込み操作の最終アドレスは、address() + offsetとして表すことができます。
  
  str - このセグメントに書き込まれるJava文字列。
  
  例外:
  
  IndexOutOfBoundsException - offset < 0またはoffset > byteSize() - str.getBytes().length() + 1の場合。
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
- ofBuffer
  
  static MemorySegment^PREVIEW ofBuffer(Buffer buffer)
  
  指定されたBufferインスタンスをバックするメモリーの同じリージョンに基づくメモリー・セグメントを作成します。セグメントはバッファ位置(inclusive)から相対的に始まり、バッファ制限(exclusive)に対して相対的に終わります。
  バッファがread-onlyの場合、結果のセグメントもread-onlyになります。さらに、バッファが「ダイレクト・バッファ」の場合、返されるセグメントはネイティブ・セグメントです。それ以外の場合、返されるメモリー・セグメントはヒープ・セグメントです。
  scope^PREVIEWがSのメモリー・セグメントでasByteBuffer()をコールして指定されたバッファが取得された場合、返されるセグメントは同じスコープSに関連付けられます。それ以外の場合、返されるセグメントのスコープは、常に存在する新しいスコープです。
  返されるセグメントに関連付けられたスコープは、指定されたバッファに到達可能な状態に保ちます。したがって、指定されたバッファが直接バッファである場合、返されたセグメント (またはいずれかのスライス)が到達可能なままであるかぎり、そのバッキング・メモリー・リージョンは解放されません。
  
  パラメータ:
  
  buffer - 新しいメモリー・セグメントに変換されるバッファ・インスタンス。
  
  戻り値:
  
  指定されたバッファ・インスタンスから導出されたメモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - 指定されたbufferがヒープ・バッファですが、配列によってバックアップされていない場合。たとえば、(CharBuffer.wrap(CharSequence)またはCharBuffer.wrap(char[], int, int)を介して直接または間接的に取得されたバッファは、配列によってバックアップされません。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(byte[] byteArray)
  
  指定されたバイト配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  byteArray - ヒープ・メモリー・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  バイト配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(char[] charArray)
  
  指定されたchar配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  charArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  char配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(short[] shortArray)
  
  指定された短い配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  shortArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  短い配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(int[] intArray)
  
  指定されたint配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  intArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  int配列によって支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(float[] floatArray)
  
  指定された浮動小数配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  floatArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  float配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(long[] longArray)
  
  指定された長い配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  longArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  ロング・アレイに支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(double[] doubleArray)
  
  指定された二重配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントのスコープは、常に有効である新しいスコープであり、指定された配列に到達可能な状態に保ちます。返されるセグメントには、すべてのスレッドから常にアクセスできます。 address()はゼロに設定されます。
  
  パラメータ:
  
  doubleArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  二重配列に支えられたヒープ・メモリー・セグメント。
- ofAddress
  
  static MemorySegment^PREVIEW ofAddress(long address)
  
  指定された「アドレス値」から長さゼロのネイティブ・セグメントを作成します。返されるセグメントは、常に有効で、どのスレッドからでもアクセスできるスコープに関連付けられます。
  32ビット・プラットフォームでは、返されるメモリー・セグメントのaddressの最上位の ("左端") 32ビットがゼロに設定されるように、指定されたアドレス値が正規化されます。
  
  パラメータ:
  
  address - 返されるネイティブ・セグメントのアドレス。
  
  戻り値:
  
  指定されたアドレスの長さがゼロのネイティブ・セグメント。
- copy
  
  static void copy(MemorySegment^PREVIEW srcSegment, long srcOffset, MemorySegment^PREVIEW 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に関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(srcSegment.isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment.isAccessibleBy(T) == falseなど)。
  
  IndexOutOfBoundsException - srcOffset > srcSegment.byteSize() - bytesまたはdstOffset > dstSegment.byteSize() - bytesの場合、またはsrcOffset、dstOffsetまたはbytesのいずれかが< 0の場合。
  
  UnsupportedOperationException - dstSegmentがread-onlyの場合。
- copy
  
  static void copy(MemorySegment^PREVIEW srcSegment, ValueLayout^PREVIEW srcElementLayout, long srcOffset, MemorySegment^PREVIEW dstSegment, ValueLayout^PREVIEW dstElementLayout, long dstOffset, long elementCount)
  
  ソース・セグメントから宛先セグメントへの一括コピーを実行します。特に、Sが要素レイアウトのバイト・サイズである場合、ソース・セグメントのオフセットsrcOffsetからsrcOffset + (elementCount * S) - 1のバイトは、オフセットdstOffsetからdstOffset + (elementCount * S) - 1の宛先セグメントにコピーされます。
  コピーはエレメント・ワイズ方式で行われます: ソース・セグメントのバイトは、レイアウトがsrcElementLayoutである要素のシーケンスとして解釈されますが、宛先セグメントのバイトは、レイアウトがdstElementLayoutである要素のシーケンスとして解釈されます。どちらの要素レイアウトも、同じサイズSである必要があります。 2つの要素レイアウトのバイト順序が異なる場合、コピーする各要素に対応するバイトは、コピー操作中にそれに応じてスワップされます。
  ソース・セグメントが宛先セグメントと重複する場合、コピーは、ソース・セグメントのオフセットsrcOffsetからsrcOffset + (elementCount * S) - 1までのバイトが最初にサイズbytesの一時セグメントにコピーされたかのように実行され、その後、一時セグメントの内容がオフセットdstOffsetからdstOffset + (elementCount * S) - 1の宛先セグメントにコピーされました。
  一括コピーの結果は、通常の場合、ソース・セグメントと宛先セグメントが重複せず、異なるアドレスを使用して同じバッキング・ストレージの重複するリージョンを参照する場合に指定されません。たとえば、同じファイルが複数のセグメントに対して「マップ済」である場合に発生することがあります。
  
  パラメータ:
  
  srcSegment - ソース・セグメント。
  
  srcElementLayout - ソース・セグメントに関連付けられたエレメント・レイアウト。
  
  srcOffset - ソース・セグメントの開始オフセット(バイト単位)。
  
  dstSegment - 宛先セグメント。
  
  dstElementLayout - 宛先セグメントに関連付けられた要素レイアウト。
  
  dstOffset - 宛先セグメントの開始オフセット(バイト単位)。
  
  elementCount - コピーする要素の数。
  
  例外:
  
  IllegalArgumentException - 要素レイアウトのサイズが異なる場合、ソース(応答宛先)要素レイアウトのソース(応答宛先)セグメント/オフセットが「線形制約と互換性がありません」の場合、またはソースの(応答宛先)要素レイアウトの位置合せがそのサイズより大きい場合。
  
  IllegalStateException - srcSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(srcSegment().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - dstSegmentがread-onlyの場合。
  
  IndexOutOfBoundsException - elementCount * srcLayout.byteSize()またはelementCount * dtsLayout.byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize())の場合。
  
  IndexOutOfBoundsException - srcOffset、dstOffsetまたはelementCountが< 0の場合。
- get
  
  default byte get(ValueLayout.OfByte^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからバイトを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたバイト値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfByte^PREVIEW layout, long offset, byte value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにバイトを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるbyte値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default boolean get(ValueLayout.OfBoolean^PREVIEW layout, long offset)
  
  指定されたオフセットを使用して、このセグメントからブールを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたブール値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfBoolean^PREVIEW layout, long offset, boolean value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにブール値を書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるブール値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default char get(ValueLayout.OfChar^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからcharを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られる文字値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfChar^PREVIEW layout, long offset, char value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントに文字を書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるchar値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default short get(ValueLayout.OfShort^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからshortを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた短い値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfShort^PREVIEW layout, long offset, short value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにshortを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるshort値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default int get(ValueLayout.OfInt^PREVIEW layout, long offset)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからintを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたint値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfInt^PREVIEW layout, long offset, int value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにintを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるint値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default float get(ValueLayout.OfFloat^PREVIEW layout, long offset)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからフロートを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた浮動小数点値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfFloat^PREVIEW layout, long offset, float value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにフロートを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるfloat値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default long get(ValueLayout.OfLong^PREVIEW layout, long offset)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからlongを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた長い値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfLong^PREVIEW layout, long offset, long value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにlongを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるlong値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default double get(ValueLayout.OfDouble^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントから倍精度浮動小数点数を読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた二重値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(ValueLayout.OfDouble^PREVIEW layout, long offset, double value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにdoubleを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるdouble値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default MemorySegment^PREVIEW get(AddressLayout^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからアドレスを読み取ります。読み取りアドレスはネイティブ・セグメントにラップされ、常に有効である新しいスコープに関連付けられます。通常の状況では、返されるセグメントのサイズは0です。ただし、指定されたアドレス・レイアウトに「ターゲット・レイアウト」^PREVIEW Tがある場合、返されるセグメントのサイズはT.byteSize()に設定されます。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたアドレスをラップするネイティブ・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IllegalArgumentException - 指定されたアドレス・レイアウトに「ターゲット・レイアウト」^PREVIEW Tがあり、Tの「線形制約と互換性がない」返されたセグメントのアドレスがある場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
- set
  
  default void set(AddressLayout^PREVIEW layout, long offset, MemorySegment^PREVIEW value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにアドレスを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるアドレス値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - offset > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
  
  UnsupportedOperationException - valueが「ネイティブ」セグメントでない場合。
- getAtIndex
  
  default byte getAtIndex(ValueLayout.OfByte^PREVIEW layout, long index)
  
  指定されたインデックスのこのセグメントからバイトを読み取り、指定されたレイアウト・サイズでスケーリングします。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られたバイト値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- getAtIndex
  
  default boolean getAtIndex(ValueLayout.OfBoolean^PREVIEW layout, long index)
  
  指定されたインデックスのこのセグメントからブール値を読み取り、指定されたレイアウト・サイズでスケーリングします。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られたブール値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- getAtIndex
  
  default char getAtIndex(ValueLayout.OfChar^PREVIEW layout, long index)
  
  指定された索引のこのセグメントから、指定されたレイアウト・サイズで拡大縮小されたcharを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られる文字値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfChar^PREVIEW layout, long index, char value)
  
  指定された索引で、指定されたレイアウト・サイズでスケールされたcharをこのセグメントに書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるchar値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default short getAtIndex(ValueLayout.OfShort^PREVIEW layout, long index)
  
  指定された索引のこのセグメントから、指定されたレイアウト・サイズでスケールされたshortを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られた短い値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfByte^PREVIEW layout, long index, byte value)
  
  指定されたインデックスのこのセグメントにバイトを書き込み、指定されたレイアウト・サイズでスケーリングします。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるshort値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfBoolean^PREVIEW layout, long index, boolean value)
  
  指定されたインデックスのこのセグメントにブール値を書き込み、指定されたレイアウト・サイズでスケーリングします。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるshort値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfShort^PREVIEW layout, long index, short value)
  
  指定された索引で、指定されたレイアウト・サイズでスケールされたこのセグメントにshortを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるshort値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default int getAtIndex(ValueLayout.OfInt^PREVIEW layout, long index)
  
  指定されたレイアウト・サイズでスケールされた、指定された索引のこのセグメントからintを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られたint値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfInt^PREVIEW layout, long index, int value)
  
  指定された索引で、指定されたレイアウト・サイズでスケールされたintをこのセグメントに書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるint値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default float getAtIndex(ValueLayout.OfFloat^PREVIEW layout, long index)
  
  指定された索引のこのセグメントからフロートを読み取り、指定されたレイアウト・サイズでスケールします。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られた浮動小数点値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfFloat^PREVIEW layout, long index, float value)
  
  指定された索引でこのセグメントにフロートを書き込み、指定されたレイアウト・サイズでスケールします。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるfloat値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default long getAtIndex(ValueLayout.OfLong^PREVIEW layout, long index)
  
  指定された索引でこのセグメントから、指定されたレイアウト・サイズでスケールされたlongを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られた長い値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfLong^PREVIEW layout, long index, long value)
  
  指定された索引で、所定のレイアウト・サイズでスケールされたlongをこのセグメントに書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるlong値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default double getAtIndex(ValueLayout.OfDouble^PREVIEW layout, long index)
  
  指定された索引で、指定されたレイアウト・サイズで倍精度浮動小数点数を読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られた二重値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfDouble^PREVIEW layout, long index, double value)
  
  指定された索引で、指定されたレイアウト・サイズでスケールされた倍精度浮動小数点数をこのセグメントに書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるdouble値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default MemorySegment^PREVIEW getAtIndex(AddressLayout^PREVIEW layout, long index)
  
  指定されたインデックスの指定されたセグメントからアドレスを読み取り、指定されたレイアウト・サイズでスケーリングします。読み取りアドレスはネイティブ・セグメントにラップされ、常に有効である新しいスコープに関連付けられます。通常の状況では、返されるセグメントのサイズは0です。ただし、指定されたアドレス・レイアウトに「ターゲット・レイアウト」^PREVIEW Tがある場合、返されるセグメントのサイズはT.byteSize()に設定されます。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られたアドレスをラップするネイティブ・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IllegalArgumentException - 指定されたアドレス・レイアウトに「ターゲット・レイアウト」^PREVIEW Tがあり、Tの「線形制約と互換性がない」返されたセグメントのアドレスがある場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
- setAtIndex
  
  default void setAtIndex(AddressLayout^PREVIEW layout, long index, MemorySegment^PREVIEW value)
  
  指定された索引で、指定されたレイアウト・サイズでスケールされたアドレスをこのセグメントに書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるアドレス値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - index * byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - index * byteSize() > byteSize() - layout.byteSize()の場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
  
  UnsupportedOperationException - valueが「ネイティブ」セグメントでない場合。
- equals
  
  boolean equals(Object that)
  指定されたオブジェクトをこのメモリー・セグメントと比較し、等しいかどうかを調べます。指定されたオブジェクトがメモリー・セグメントでもある場合、および2つのセグメントが同じロケーションを参照する場合にのみ、メモリーの一部のリージョンでtrueを返します。具体的には、2つのセグメントs1とs2を等しいとみなす場合、次のすべてがtrueである必要があります:
  
  s1.heapBase().equals(s2.heapBase())。つまり、2つのセグメントは同じ種類である必要があります。両方とも「ネイティブ・セグメント」、オフ・ヒープ・メモリーによってバックアップされるか、または両方が同じオン・ヒープ「Javaオブジェクト」によってバックアップされます
  s1.address() == s2.address()。つまり、2つのセグメントのアドレスは同じである必要があります。つまり、2つのセグメントは、一部のオフ・ヒープ・リージョンの同じロケーションを参照するか、関連付けられた「Javaオブジェクト」内の同じオフセットを参照します。
  オーバーライド:
  
  equals、クラスObject
  
  APIのノート:
  
  このメソッドでは、2つのメモリー・セグメントの内容の構造比較は実行されません。クライアントは、かわりにmismatch(MemorySegment)メソッドを使用してメモリー・セグメントを構造的に比較できます。このメソッドは、2つのセグメントの一時的および空間的な境界を比較しません。そのため、2つのセグメントに同じアドレスがあるかどうかを確認することが適切です。
  
  パラメータ:
  
  that - このメモリー・セグメントとの等価性を比較するオブジェクト。
  
  戻り値:
  
  指定されたオブジェクトがこのメモリー・セグメントと等しい場合は、true。
  
  関連項目:
  
  mismatch(MemorySegment)
- hashCode
  
  int hashCode()
  
  このメモリー・セグメントのハッシュ・コード値を返します。
  オーバーライド:
  
  hashCode、クラスObject
  
  戻り値:
  
  このメモリー・セグメントのハッシュ・コード値
  
  関連項目:
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- copy
  
  static void copy(MemorySegment^PREVIEW srcSegment, ValueLayout^PREVIEW srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)
  
  ソース・メモリー・セグメントから宛先配列に多数の要素をコピーします。指定されたレイアウトによってサイズおよび整列制約が指定されている要素は、指定されたオフセット(バイトで表されます。)からソース・セグメントから読み取られ、指定された索引で宛先配列にコピーされます。サポートされる配列タイプは、byte[], char[], short[], int[], float[], long[]およびdouble[]です。
  
  パラメータ:
  
  srcSegment - ソース・セグメント。
  
  srcLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  srcOffset - ソース・セグメントの開始オフセット(バイト単位)。
  
  dstArray - 宛先配列。
  
  dstIndex - 宛先配列の開始索引。
  
  elementCount - コピーする配列要素の数。
  
  例外:
  
  IllegalStateException - srcSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  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^PREVIEW dstSegment, ValueLayout^PREVIEW dstLayout, long dstOffset, int elementCount)
  
  ソース配列から宛先メモリー・セグメントに多数の要素をコピーします。指定されたレイアウトによってサイズおよび整列制約が指定されている要素は、指定された索引から開始してソース配列から読み取られ、指定されたオフセット(バイトで表されます。)で宛先セグメントにコピーされます。サポートされる配列タイプは、byte[], char[], short[], int[], float[], long[]およびdouble[]です。
  
  パラメータ:
  
  srcArray - ソース配列。
  
  srcIndex - ソース配列の開始インデックス。
  
  dstSegment - 宛先セグメント。
  
  dstLayout - 宛先要素レイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  dstOffset - 宛先セグメントの開始オフセット(バイト単位)。
  
  elementCount - コピーする配列要素の数。
  
  例外:
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - srcArrayが配列でない場合、または配列であり、その型がサポートされていない場合。
  
  IllegalArgumentException - ソース配列コンポーネント・タイプがsrcLayout.carrier()と一致しない場合。
  
  IllegalArgumentException - ソース要素レイアウトでoffsetが「線形制約と互換性がありません」の場合。
  
  IllegalArgumentException - dstLayout.byteAlignment() > dstLayout.byteSize()の場合。
  
  UnsupportedOperationException - dstSegmentがread-onlyの場合。
  
  IndexOutOfBoundsException - elementCount * dstLayout.byteSize()がオーバーフローした場合。
  
  IndexOutOfBoundsException - dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize())の場合。
  
  IndexOutOfBoundsException - srcIndex > srcArray.length - elementCountの場合。
  
  IndexOutOfBoundsException - srcIndex、dstOffsetまたはelementCountが< 0の場合。
- mismatch
  
  static long mismatch(MemorySegment^PREVIEW srcSegment, long srcFromOffset, long srcToOffset, MemorySegment^PREVIEW dstSegment, long dstFromOffset, long dstToOffset)
  
  ソース・セグメントと宛先セグメント間の最初の不一致の相対オフセットをバイト単位で検索して返します。具体的には、ソース・セグメントのオフセットsrcFromOffsetからsrcToOffset - 1までのバイトが、宛先セグメントのオフセットdstFromOffsetからdstToOffset - 1までのバイトと比較されます。
  指定された範囲の2つのセグメントが共通のプレフィクスを共有している場合、返されるオフセットは共通のプレフィクスの長さであり、それぞれのセグメント内のその相対オフセットにある2つのセグメント間に不一致があることを示しています。 1つのセグメントがもう一方のセグメントの適切なプレフィクスである場合、返されるオフセットは最小範囲になり、相対オフセットは大きい範囲のセグメントに対してのみ有効になります。それ以外の場合、不一致はなく、-1が返されます。
  パラメータ:
  
  srcSegment - ソース・セグメント。
  
  srcFromOffset - テストするソース・セグメントの最初のバイトのオフセット(inclusive)。
  
  srcToOffset - テストするソース・セグメントの最後のバイトのオフセット(exclusive)。
  
  dstSegment - 宛先セグメント。
  
  dstFromOffset - テスト対象の宛先セグメント内の最初のバイトのオフセット (inclusive)。
  
  dstToOffset - テスト対象の宛先セグメントの最後のバイトのオフセット (exclusive)。
  
  戻り値:
  
  ソース・セグメントと宛先セグメント間で最初の不一致の相対オフセット(バイト単位)。一致しない場合は -1。
  
  例外:
  
  IllegalStateException - srcSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(srcSegment.isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment.isAccessibleBy(T) == falseなど)。
  
  IndexOutOfBoundsException - srcFromOffset < 0、srcToOffset < srcFromOffsetまたはsrcToOffset > srcSegment.byteSize()の場合
  
  IndexOutOfBoundsException - dstFromOffset < 0、dstToOffset < dstFromOffsetまたはdstToOffset > dstSegment.byteSize()の場合
  
  関連項目:
  
  mismatch(MemorySegment)
  
  Arrays.mismatch(Object[], int, int, Object[], int, int)

配列タイプ(バッキング・リージョン)	サポートされる最大アライメント (バイト単位)
`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

メモリー・セグメントの特性

メモリー・セグメントへのアクセス

メモリー・セグメントのスライス

位置合せ

長さゼロのメモリー・セグメント

ネストされたクラスのサマリー

フィールドのサマリー

メソッドのサマリー

フィールド詳細

NULL

メソッドの詳細

address

heapBase

spliterator

elements

scope

isAccessibleBy

byteSize

asSlice

asSlice

asSlice

asSlice

reinterpret

reinterpret

reinterpret

isReadOnly

asReadOnly

isNative

isMapped

asOverlappingSlice

segmentOffset

fill

copyFrom

mismatch

isLoaded

load

unload

force

asByteBuffer

toArray

toArray

toArray

toArray

toArray

toArray

toArray

getUtf8String

setUtf8String

ofBuffer

ofArray

ofArray

ofArray

ofArray

ofArray

ofArray

ofArray

ofAddress

copy

copy

get

set

get

set

get

set

get

set

get

set

get

set

get

set

get

set

get

set

getAtIndex

getAtIndex