public sealed interface MemorySegment

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

最後に、メモリー・セグメントに対するアクセス操作は、関連するスコープによって強制されるスレッド競合チェックの対象となります。つまり、セグメントが「グローバル・スコープ」^PREVIEWまたは「自動スコープ」^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, 4L));
intHandle.get(segment, 3L); // get int element at offset 3 * 4 = 12

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

MemorySegment segment = ...
VarHandle intHandle = ValueLayout.JAVA_INT.arrayElementVarHandle();
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を取得できます。これにより、セグメント(指定された要素レイアウトに従って)をスライスするために使用でき、また、結合されていないセグメント・スライス(これを行うには、セグメントを複数のスレッドからaccess^PREVIEWを許可するスコープに関連付ける必要があります)で複数のスレッドをパラレルに動作させることができます。次のコードを使用すると、メモリー・セグメント内のすべてのint値を並列に合計できます:

 try (Arena arena = Arena.openShared()) {
     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バイトの値のシーケンスを格納する場合は、allocateNative(long, long, SegmentScope)またはallocateNative(MemoryLayout, SegmentScope)を使用して8バイトの整列制約を指定してセグメントを割り当てる必要があります。これらのファクトリは、返されるセグメントを裏付けるメモリーのオフ・ヒープ・リージョンに、8バイトの整列された開始アドレスがあることを確認します。その後、プログラマは関心のある相殺でセグメントにアクセスできます -- 0、8、16、24など -- そのようなすべてのアクセスが合致しているという知識。

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

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

long[]配列の開始物理アドレスは8バイトの境界整列 (e.g. 1000)になるため、連続する長い要素が8バイト境界整列されたアドレス (e.g., 1000, 1008, 1016, 1024, etc.) 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などでセグメントにアクセスできます。
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に対応します。

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

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

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

boolean[] 1

byte[] 1

char[] 2

short[] 2

int[] 4

float[] 4

long[] 8

double[] 8

ヒープ・セグメントには、ヒープ・セグメントに関連付けられた最大整列以下の整列を持つレイアウトを使用してのみアクセスできます。次の例に示すように、位置合せがヒープ・セグメントに関連付けられた最大位置合せより大きいレイアウトを使用してヒープ・セグメントにアクセスしようとすると失敗します:

MemorySegment byteSegment = MemorySegment.ofArray(new byte[10]);
byteSegment.get(ValueLayout.JAVA_INT, 0); // fails: layout alignment is 4, segment max alignment is 1

このような場合、クライアントには2つのオプションがあります。異なる配列タイプ(e.g. long[])でバックアップされるヒープ・セグメントを使用すると、最大長の配置をサポートできます:

MemorySegment longSegment = MemorySegment.ofArray(new long[10]);
longSegment.get(ValueLayout.JAVA_INT, 0); // ok: layout alignment is 4, segment max alignment is 8

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

MemorySegment byteSegment = MemorySegment.ofArray(new byte[10]);
byteSegment.get(ValueLayout.JAVA_INT_UNALIGNED, 0); // ok: layout alignment is 1, segment max alignment is 1

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

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

Linker^PREVIEWは、「長さゼロのメモリー・セグメント」を使用して外部関数から返されるポインタを表します。セグメントのアドレスは、ポインタに格納されているアドレスです。セグメントのサイズはゼロです。同様に、クライアントがメモリー・セグメントからaddressを読み取ると、長さゼロのメモリー・セグメントが返されます。

長さ0のセグメントには簡単な空間境界があるため、これらのセグメントにアクセスしようとすると、IndexOutOfBoundsExceptionで失敗します。これは重要な安全機能です: これらのセグメントは、サイズが不明なメモリー・リージョンに関連付けられているため、これらのセグメントに関連するアクセス操作は検証できません。実際には、長さゼロのメモリー・セグメントはアドレスを「ラップ」し、明示的なインテントなしでは使用できません。

外部関数との相互作用時に取得される長さゼロのメモリー・セグメントは、global scope^PREVIEWに関連付けられます。これは、Javaランタイムが、外部関数から戻されたポインタをバッキングするメモリー・リージョンのサイズを把握しないことに加えて、そのメモリーを割り当てた外部関数によって指定されたメモリー・リージョンの存続期間についてのインサイトも得られないためです。大域スコープは、取得されたセグメントをほかのポインタ受け入れ外部関数に不当に渡せるようにします。

ネイティブの長さゼロのメモリー・セグメントにアクセスするには、クライアントには2つのオプションがあり、どちらもunsafeです。クライアントは、次のように、newネイティブ・セグメントを「入手」し、新しい空間および時間範囲を使用できます:

 SegmentScope scope = ... // obtains a scope
 MemorySegment foreign = someSegment.get(ValueLayout.ADDRESS, 0); // wrap address into segment (size = 0)
 MemorySegment segment = MemorySegment.ofAddress(foreign.address(), 4, scope); // create new segment (size = 4)
 int x = segment.get(ValueLayout.JAVA_INT, 0); //ok

または、クライアントは「制限なし」^PREVIEWアドレス値のレイアウトを取得できます。アクセス操作またはダウン・コール・メソッド・ハンドルに渡される関数記述子が、バインドされていないアドレス値のレイアウトを使用する場合、ランタイムは、対応するRAWアドレスをネイティブ・セグメントで「最大」サイズ(i.e. Long.MAX _VALUE)でラップします。そのため、これらのセグメントには、次のように直接アクセスできます:

 MemorySegment foreign = someSegment.get(ValueLayout.ADDRESS.asUnbounded(), 0); // wrap address into segment (size = Long.MAX_VALUE)
 int x = foreign.get(ValueLayout.JAVA_INT, 0); //ok

ofAddress(long, long, SegmentScope)とValueLayout.OfAddress.asUnbounded()^PREVIEWの両方が「制限付き」メソッドであるため、注意して使用してください: たとえば、セグメントのサイズを誤って設定すると、メモリー・セグメントにアクセスしようとしたときにVMがクラッシュする可能性があります。

どの方法を使用するかは、ネイティブ・ポインタをラップするメモリー・セグメントを取得するときにクライアントが使用できる情報によって大きく異なります。たとえば、このようなポインタがC構造体を指している場合、クライアントは、構造体 (範囲外アクセスがAPIによって検出されるようにするため)のサイズに一致するように、セグメントのサイズを安全に変更することを好みます。ただし、ほかのケースでは、特定のネイティブ・ポインタに空間境界または時間境界(あるいはその両方)を関連付ける必要のある情報はありません。このような場合は、バインドされていないアドレス・レイアウトを使用することをお勧めします。

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

フィールドのサマリー

フィールド

修飾子と型

フィールド

説明

static final MemorySegment^PREVIEW

NULL

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

修飾子と型

メソッド

説明

long

address()

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

static MemorySegment^PREVIEW

allocateNative(long byteSize, long byteAlignment, SegmentScope^PREVIEW scope)

指定されたサイズ(バイト単位)、整列(バイト単位)およびスコープでネイティブ・セグメントを作成します。

static MemorySegment^PREVIEW

allocateNative(long byteSize, SegmentScope^PREVIEW scope)

指定されたサイズ(バイト単位)およびスコープでネイティブ・セグメントを作成します。

static MemorySegment^PREVIEW

allocateNative(MemoryLayout^PREVIEW layout, SegmentScope^PREVIEW scope)

指定されたレイアウトおよびスコープでネイティブ・セグメントを作成します。

Optional<Object>

array()

このメモリー・セグメントに関連付けられているJava配列(ある場合)を返します。

ByteBuffer

asByteBuffer()

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

Optional<MemorySegment^PREVIEW>

asOverlappingSlice(MemorySegment^PREVIEW other)

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

MemorySegment^PREVIEW

asReadOnly()

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

default MemorySegment^PREVIEW

asSlice(long offset)

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

MemorySegment^PREVIEW

asSlice(long offset, long newSize)

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

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(ValueLayout.OfAddress^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(ValueLayout.OfAddress^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()

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

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

ofAddress(long address, long byteSize)

指定されたサイズおよび「アドレス値」でネイティブ・セグメントを作成します。

static MemorySegment^PREVIEW

ofAddress(long address, long byteSize, SegmentScope^PREVIEW scope)

指定されたサイズ、アドレス、およびスコープを持つネイティブ・セグメントを作成します。

static MemorySegment^PREVIEW

ofAddress(long address, long byteSize, SegmentScope^PREVIEW scope, Runnable cleanupAction)

指定されたサイズ、アドレス、およびスコープを持つネイティブ・セグメントを作成します。

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インスタンスをバックするメモリーの同じリージョンに基づくメモリー・セグメントを作成します。

SegmentScope^PREVIEW

scope()

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

long

segmentOffset(MemorySegment^PREVIEW other)

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

default void

set(ValueLayout.OfAddress^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(ValueLayout.OfAddress^PREVIEW layout, long index, MemorySegment^PREVIEW 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()
  
  このメモリー・セグメントのアドレスを返します。
  
  戻り値:
  
  このメモリー・セグメントのアドレス
- array
  
  Optional<Object> array()
  
  このメモリー・セグメントに関連付けられているJava配列(ある場合)を返します。
  
  戻り値:
  
  このメモリー・セグメントに関連付けられている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サイズがゼロの場合、またはelementLayoutサイズをモジュロとするセグメント・サイズがゼロより大きい場合、指定されたレイアウトでこのセグメントが「線形制約と互換性がありません」の場合、またはelementLayout整列がそのサイズより大きい場合。
- elements
  
  Stream<MemorySegment^PREVIEW> elements(MemoryLayout^PREVIEW elementLayout)
  このセグメント内の分離スライス(指定したレイアウトのサイズと一致するサイズ)に対して連続したStreamを返します。このメソッドの呼出しは、次のコードと同じです:
  
  StreamSupport.stream(segment.spliterator(elementLayout), false);
  パラメータ:
  
  elementLayout - 分割に使用されるレイアウト。
  
  戻り値:
  
  このセグメント内の連続したStreamスライス。
  
  例外:
  
  IllegalArgumentException - elementLayoutサイズがゼロの場合、またはelementLayoutサイズをモジュロとするセグメント・サイズがゼロより大きい場合、指定されたレイアウトでこのセグメントが「線形制約と互換性がありません」の場合、またはelementLayout整列がそのサイズより大きい場合。
- scope
  
  SegmentScope^PREVIEW scope()
  
  このメモリー・セグメントに関連付けられたスコープを返します。
  
  戻り値:
  
  このメモリー・セグメントに関連付けられたスコープ
- byteSize
  
  long byteSize()
  
  このメモリー・セグメントのサイズ(バイト単位)を返します。
  
  戻り値:
  
  このメモリー・セグメントのサイズ(バイト単位)
- asSlice
  
  MemorySegment^PREVIEW asSlice(long offset, long newSize)
  
  指定されたオフセットで、このメモリー・セグメントのスライスを返します。返されるセグメントのアドレスは、このセグメントのアドレスと指定されたオフセットです。そのサイズは、指定された引数で指定されます。
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(このセグメントのアドレスに対する相対)(バイト単位)です。
  
  newSize - 新しいセグメント・サイズ(バイト単位で指定)。
  
  戻り値:
  
  このメモリー・セグメントのスライス。
  
  例外:
  
  IndexOutOfBoundsException - offset < 0、offset > byteSize()、newSize < 0またはnewSize > byteSize() - offsetの場合
  
  関連項目:
  
  asSlice(long)
- asSlice
  
  default MemorySegment^PREVIEW asSlice(long offset)
  指定されたオフセットで、このメモリー・セグメントのスライスを返します。返されるセグメントのアドレスは、このセグメントのアドレスと指定されたオフセットの合計です。そのサイズは、このセグメント・サイズから指定されたオフセットを差し引いて計算されます。
  次のコードと同等です:
  
  asSlice(offset, byteSize() - offset);
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(このセグメントのアドレスに対する相対)(バイト単位)です。
  
  戻り値:
  
  このメモリー・セグメントのスライス。
  
  例外:
  
  IndexOutOfBoundsException - if offset < 0,またはoffset > byteSize()。
  
  関連項目:
  
  asSlice(long, long)
- isReadOnly
  
  boolean isReadOnly()
  
  このセグメントが読取り専用の場合、trueを返します。
  戻り値:
  
  true:このセグメントが読取り専用の場合
  
  関連項目:
  
  asReadOnly()
- asReadOnly
  
  MemorySegment^PREVIEW asReadOnly()
  
  このセグメントの読取り専用ビューを返します。結果のセグメントはこのセグメントと同一になりますが、返されたセグメントの内容を上書きしようとすると、ランタイム例外が発生します。
  戻り値:
  
  このセグメントの読取り専用ビュー
  
  関連項目:
  
  isReadOnly()
- isNative
  
  boolean isNative()
  
  このセグメントがネイティブ・セグメントの場合は、trueを返します。ネイティブ・セグメントは、allocateNative(long, SegmentScope) (および関連)ファクトリまたは「ラッピング」によって「ダイレクト・バッファ」を使用して作成されます。
  
  戻り値:
  
  このセグメントがネイティブ・セグメントの場合はtrue。
- isMapped
  
  boolean isMapped()
  
  このセグメントがマップされたセグメントの場合は、trueを返します。マップされたメモリー・セグメントは、FileChannel.map(FileChannel.MapMode, long, long, SegmentScope)^PREVIEWファクトリ、「ラッピング」によって「マップされたバイト・バッファ」のように作成されます。
  
  戻り値:
  
  このセグメントがマップされたセグメントである場合はtrue。
- asOverlappingSlice
  
  Optional<MemorySegment^PREVIEW> asOverlappingSlice(MemorySegment^PREVIEW other)
  
  このセグメントと指定されたセグメントの間の重複である、このセグメントのスライスを返します。
  同じメモリー・リージョンにバックアップされている2つ以上のスライスL1 (S1から)およびL2 (S2から)が見つかった場合は、2つのセグメントS1とS2が重複しているとみなされます。そのため、「ネイティブ」セグメントをヒープ・セグメントと重複させることはできません。この場合、または重複が発生しない場合、nullが返されます。
  
  パラメータ:
  
  other - このセグメントとの重複をテストするセグメント。
  
  戻り値:
  
  このセグメント(重複が発生した場合)のスライス。
- segmentOffset
  
  long segmentOffset(MemorySegment^PREVIEW other)
  このセグメントに対して指定されたセグメントのオフセット(バイト単位)を返します。
  オフセットは、このセグメントのアドレスに対する相対値であり、負または正の値にすることができます。たとえば、両方のセグメントがネイティブ・セグメントであるか、同じ配列に支えられたヒープ・セグメントである場合、結果のオフセットは次のように計算できます:
  
  other.address() - segment.address()
  
  セグメントが同じアドレスを共有している場合は、0が返されます。 otherがこのセグメントのスライスである場合、オフセットは常に0 <= x < this.byteSize()です。
  パラメータ:
  
  other - オフセットを取得するセグメント。
  
  戻り値:
  
  指定されたセグメントの相対オフセット(バイト単位)。
  
  例外:
  
  UnsupportedOperationException - 2つのセグメントを比較できない場合(異なる種類のセグメント、異なるJava配列によるバックアップなど)。
- fill
  
  MemorySegment^PREVIEW fill(byte value)
  このメモリー・セグメントに値を入力します。
  具体的には、指定された値がこのセグメントの各アドレスに入力されます。 (ただし、より効率的である可能性があります。)と同等のコードは次のとおりです:
  
  byteHandle = MemoryLayout.ofSequence(ValueLayout.JAVA_BYTE) .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement()); for (long l = 0; l < segment.byteSize(); l++) { byteHandle.set(segment.address(), l, value); }
  
  設定される特定のメモリー要素の順序を考慮または保証しません。
  フィルは、セグメントのメモリーを初期化またはリセットする場合に便利です。
  パラメータ:
  
  value - このセグメントに入力する値
  
  戻り値:
  
  このメモリー・セグメント
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントが読取り専用(isReadOnly()を参照してください)の場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - srcに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(src.scope().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントが読取り専用(isReadOnly()を参照してください)の場合。
- mismatch
  
  default long mismatch(MemorySegment^PREVIEW other)
  
  このセグメントと指定された他のセグメントとの間で最初の不一致のオフセットをバイト単位で検索して返します。オフセットは、各セグメントのaddressに相対的になり、0 (inclusive)の範囲から、小さいメモリー・セグメント (exclusive)のsize (バイト単位)までの範囲になります。
  2つのセグメントが共通プリフィクスを共有している場合、返されるオフセットは共通プリフィクスの長さであり、それぞれのセグメント内のそのオフセットで2つのセグメント間に不一致があることが後続しています。 1つのセグメントがもう一方のセグメントの適切なプレフィクスである場合、返されるオフセットはセグメント・サイズの最小値であり、オフセットは大きいセグメントに対してのみ有効です。それ以外の場合、不一致はなく、 -1が返されます。
  
  パラメータ:
  
  other - このセグメントとの不一致をテストするセグメント
  
  戻り値:
  
  このセグメントと指定された他のセグメント間の最初の不一致の相対オフセット(バイト)。不一致がない場合は -1
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - otherに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(other.scope().isAccessibleBy(T) == falseなど)。
- isLoaded
  
  boolean isLoaded()
  
  このマップされたセグメントの内容が物理メモリーに存在するかどうかを決定します。
  trueの戻り値は、このセグメント内のすべてのデータが物理メモリーに常駐している可能性が高いため、仮想メモリー・ページ・フォルトやI/O操作を行わずにアクセスできる可能性があることを意味します。戻り値のfalseは、このセグメント・コンテンツが物理メモリーに存在していないことを必ずしも意味しません。
  返される値は、保証ではなくヒントです。これは、基礎となるオペレーティング・システムが、このメソッドを呼び出したときにこのセグメント・データの一部をページアウトしたためです。
  
  戻り値:
  
  このセグメントの内容が物理メモリーに存在する可能性がある場合はtrue
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
- load
  
  void load()
  
  このマップされたセグメントの内容を物理メモリーにロードします。
  このメソッドを使用すると、このセグメントのこの内容が物理メモリーに常駐していることを確認できます。このメソッドを呼び出すと、ページ違反や入出力操作が発生する可能性があります。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
- unload
  
  void unload()
  
  このマップされたセグメントの内容を物理メモリーからアンロードします。
  このメソッドは、このセグメントのコンテンツが物理メモリーに存在しなくなるように最善の努力をします。このメソッドを呼び出した後にこのセグメントの内容にアクセスすると、いくつかのページ・フォルトおよびI/O操作が(このセグメント・コンテンツはページ・インする必要がある可能性があるため)に発生する可能性があります。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
- force
  
  void force()
  
  マップされたセグメント・ファイル記述子によって記述されたストレージ・デバイスに、このマップされたセグメントの内容に加えた変更を強制的に書き込みます。
  このマップされたセグメントに関連付けられているファイル記述子がローカル・ストレージ・デバイスに存在する場合、このメソッドが返すとき、このセグメントが作成されてからこのセグメントに加えられたすべての変更、またはこのメソッドが最後に呼び出されてから、そのデバイスに書き込まれていることが保証されます。
  このマップされたセグメントに関連付けられているファイル記述子がローカル・デバイスに存在しない場合は、そのような保証は行われません。
  このセグメントが読取り/書込みモードの(FileChannel.MapMode.READ_WRITE)でマップされていない場合、このメソッドを呼び出しても効果がない可能性があります。特に、このメソッドは、読取り専用またはプライベート・マッピング・モードでマップされたセグメントには影響しません。このメソッドは、実装固有のマッピング・モードに有効である場合も、そうでない場合もあります。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  UnsupportedOperationException - このセグメントがマップされたメモリー・セグメントでない場合(例: isMapped() == false)。
  
  UncheckedIOException - このセグメントの内容を関連するストレージ・デバイスに書き込むI/Oエラーがある場合
- asByteBuffer
  
  ByteBuffer asByteBuffer()
  
  ByteBufferでこのセグメントをラップします。返されるバッファの一部のプロパティは、このセグメントのプロパティにリンクされます。たとえば、このセグメントが「不変」 (たとえば、セグメントは読取り専用セグメントです。isReadOnly()を参照してください)の場合、生成されるバッファはread-only (Buffer.isReadOnly()を参照してください)です。さらに、これがネイティブ・セグメントの場合、結果のバッファはdirect (ByteBuffer.isDirect()を参照してください)です。
  戻されるバッファ位置(Buffer.position()を参照してください)は最初はゼロに設定されますが、戻されるバッファ容量および制限(Buffer.capacity()およびBuffer.limit()をそれぞれ参照)はこのセグメントのサイズ(byteSize()を参照してください)に設定されます。このため、このセグメントのサイズがInteger.MAX_VALUEより大きい場合、byteバッファは返されません。
  返されるバッファのライフサイクルは、このセグメントのライフサイクルと関連します。つまり、このセグメントに関連付けられたスコープがalive^PREVIEWではなくなった後に返されるバッファにアクセスすると、IllegalStateExceptionがスローされます。同様に、スレッドTから戻されたバッファにアクセスして、scope().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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - このセグメント・コンテンツをbyte[]インスタンスにコピーできない場合(サイズがInteger.MAX_VALUEより大きい場合など)。
- toArray
  
  short[] toArray(ValueLayout.OfShort^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい短い配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい短い配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - たとえば、byteSize() % 2 != 0またはbyteSize() / 2 > Integer#MAX_VALUEのため、このセグメントの内容をchar[]インスタンスにコピーできない場合。
- toArray
  
  int[] toArray(ValueLayout.OfInt^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しいint配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しいint配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - たとえば、byteSize() % 4 != 0またはbyteSize() / 4 > Integer#MAX_VALUEのため、このセグメントの内容をint[]インスタンスにコピーできない場合。
- toArray
  
  float[] toArray(ValueLayout.OfFloat^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい浮動小数配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい浮動小数配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - たとえば、byteSize() % 4 != 0またはbyteSize() / 4 > Integer#MAX_VALUEのため、このセグメントの内容をfloat[]インスタンスにコピーできない場合。
- toArray
  
  long[] toArray(ValueLayout.OfLong^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい長い配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい長い配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - たとえば、byteSize() % 8 != 0またはbyteSize() / 8 > Integer#MAX_VALUEのため、このセグメントの内容をlong[]インスタンスにコピーできない場合。
- toArray
  
  double[] toArray(ValueLayout.OfDouble^PREVIEW elementLayout)
  
  このメモリー・セグメントの内容を新しい二重配列にコピーします。
  
  パラメータ:
  
  elementLayout - ソース要素のレイアウト。レイアウトに関連付けられたバイト順序が「ネイティブ・オーダー」と異なる場合、各配列要素に対してバイト・スワップ演算が実行されます。
  
  戻り値:
  
  このメモリー・セグメントから内容がコピーされる新しい二重配列。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - たとえば、byteSize() % 8 != 0またはbyteSize() / 8 > Integer#MAX_VALUEのため、このセグメントの内容をdouble[]インスタンスにコピーできない場合。
- getUtf8String
  
  default String getUtf8String(long offset)
  
  指定されたオフセットでこのセグメントからUTF-8エンコードされたNULL終了文字列を読み取ります。
  このメソッドは、不正入力シーケンスやマップ不可文字シーケンスを、この文字セットのデフォルトの置換文字列で置き換えます。デコード処理をより強力に制御する必要がある場合、CharsetDecoderクラスを使用する必要があります。
  
  パラメータ:
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  指定された開始アドレスから読み取られたバイト数から、最初の'\0'終了文字(見つかったもの) (含まない)までのJava文字列。
  
  例外:
  
  IllegalArgumentException - UTF-8文字列のサイズがプラットフォームでサポートされる最大の文字列より大きい場合。
  
  IndexOutOfBoundsException - offset < 0またはS + offset > byteSize()の場合、SはUTF-8文字列(終端文字を含む)のサイズです。
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().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またはstr.getBytes().length() + offset >= byteSize()の場合。
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
- ofBuffer
  
  static MemorySegment^PREVIEW ofBuffer(Buffer buffer)
  指定されたBufferインスタンスをバックするメモリーの同じリージョンに基づくメモリー・セグメントを作成します。セグメントはバッファ位置(inclusive)から相対的に始まり、バッファ制限(exclusive)に対して相対的に終わります。
  バッファがread-onlyの場合、結果のセグメントもread-onlyになります。さらに、バッファが「ダイレクト・バッファ」の場合、返されるセグメントはネイティブ・セグメントです。それ以外の場合、返されるメモリー・セグメントはヒープ・セグメントです。
  返されるセグメントに関連付けられたスコープSは次のように計算されます:
  
  スコープがS'のメモリー・セグメントでasByteBuffer()をコールしてバッファが取得された場合は、S = S' ;または
  
  バッファがヒープ・バッファの場合、Sは「グローバル・スコープ」^PREVIEWです
  バッファが直接バッファの場合、Sは、常に有効であり、バッファが到達可能なままであるスコープです。したがって、返されるセグメントが到達可能であれば、バッファ・インスタンスをサポートするメモリーのオフ・ヒープ・リージョンは使用可能なままになります。
  パラメータ:
  
  buffer - 新しいメモリー・セグメントに変換されるバッファ・インスタンス。
  
  戻り値:
  
  指定されたバッファ・インスタンスから導出されたメモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - 指定されたbufferがヒープ・バッファですが、配列によってバックアップされていない場合。たとえば、(CharBuffer.wrap(CharSequence)またはCharBuffer.wrap(char[], int, int)を介して直接または間接的に取得されたバッファは、配列によってバックアップされません。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(byte[] byteArray)
  
  指定されたバイト配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  byteArray - ヒープ・メモリー・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  バイト配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(char[] charArray)
  
  指定されたchar配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  charArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  char配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(short[] shortArray)
  
  指定された短い配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  shortArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  短い配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(int[] intArray)
  
  指定されたint配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  intArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  int配列によって支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(float[] floatArray)
  
  指定された浮動小数配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  floatArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  float配列に支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(long[] longArray)
  
  指定された長い配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  longArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  ロング・アレイに支えられたヒープ・メモリー・セグメント。
- ofArray
  
  static MemorySegment^PREVIEW ofArray(double[] doubleArray)
  
  指定された二重配列を保持するメモリーのオン・ヒープ・リージョンによって支えられたヒープ・セグメントを作成します。返されるセグメントは「グローバル・スコープ」^PREVIEWに関連付けられ、そのaddress()はゼロに設定されます。
  
  パラメータ:
  
  doubleArray - ヒープ・セグメントを支えるプリミティブ配列。
  
  戻り値:
  
  二重配列に支えられたヒープ・メモリー・セグメント。
- ofAddress
  
  static MemorySegment^PREVIEW ofAddress(long address)
  指定された「アドレス値」から長さゼロのネイティブ・セグメントを作成します。返されるセグメントは、「グローバル・スコープ」^PREVIEWに関連付けられます。
  これは次のコードと等価です。
  
  ofAddress(address, 0);
  パラメータ:
  
  address - 返されるネイティブ・セグメントのアドレス。
  
  戻り値:
  
  指定されたアドレスの長さがゼロのネイティブ・セグメント。
- ofAddress
  
  static MemorySegment^PREVIEW ofAddress(long address, long byteSize)
  指定されたサイズおよび「アドレス値」でネイティブ・セグメントを作成します。返されるセグメントは、「グローバル・スコープ」^PREVIEWに関連付けられます。
  これは次のコードと等価です。
  
  ofAddress(address, byteSize, SegmentScope.global());
  
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  パラメータ:
  
  address - 返されるネイティブ・セグメントのアドレス。
  
  byteSize - 返されるネイティブ・セグメントのサイズ(バイト単位)。
  
  戻り値:
  
  指定されたアドレスとサイズを持つ長さゼロのネイティブ・セグメント。
  
  例外:
  
  IllegalArgumentException - byteSize < 0の場合。
  
  IllegalCallerException - 呼び出し元が、ネイティブ・アクセスが有効になっていないモジュール内にある場合。
- ofAddress
  
  static MemorySegment^PREVIEW ofAddress(long address, long byteSize, SegmentScope^PREVIEW scope)
  指定されたサイズ、アドレス、およびスコープを持つネイティブ・セグメントを作成します。このメソッドは、カスタム・メモリー・ソース(例:カスタム・ロケータ)と対話する場合に便利です。この場合、メモリーの基礎となる一部のリージョンへのアドレスは、通常、外部コード(プレーンlong値として使用されることが多い)から取得されます。
  返されるセグメントは読取り専用(isReadOnly()を参照してください)ではなく、指定されたスコープに関連付けられます。
  これは次のコードと等価です。
  
  ofAddress(address, byteSize, scope, null);
  
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  パラメータ:
  
  address - 返されるセグメントのアドレス。
  
  byteSize - 目的のサイズ。
  
  scope - 返されるネイティブ・セグメントに関連付けられたスコープ。
  
  戻り値:
  
  指定されたアドレス、サイズ、およびスコープを持つネイティブ・セグメント。
  
  例外:
  
  IllegalArgumentException - byteSize < 0の場合。
  
  IllegalStateException - scopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope.isAccessibleBy(T) == falseなど)。
  
  IllegalCallerException - 呼び出し元が、ネイティブ・アクセスが有効になっていないモジュール内にある場合。
- ofAddress
  
  static MemorySegment^PREVIEW ofAddress(long address, long byteSize, SegmentScope^PREVIEW scope, Runnable cleanupAction)
  
  指定されたサイズ、アドレス、およびスコープを持つネイティブ・セグメントを作成します。このメソッドは、カスタム・メモリー・ソース(例:カスタム・ロケータ)と対話する場合に便利です。この場合、メモリーの基礎となる一部のリージョンへのアドレスは、通常、外部コード(プレーンlong値として使用されることが多い)から取得されます。
  返されるセグメントは読取り専用(isReadOnly()を参照してください)ではなく、指定されたスコープに関連付けられます。
  指定されたクリーン・アップ・アクション(もしあれば)は、スコープがalive^PREVIEWでない場合に起動されます。
  クライアントは、アドレスと境界が、読み取りおよび書き込みのためにアクセス可能なメモリーの有効なリージョンを参照していることを確認する必要があります。Javaコードから無効なアドレスにアクセスしようとすると、任意の値が返されるか、目に見える影響がないか、未指定の例外がスローされます。
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  
  パラメータ:
  
  address - 返されるセグメントのアドレス。
  
  byteSize - 目的のサイズ。
  
  scope - 返されるネイティブ・セグメントに関連付けられたスコープ。
  
  cleanupAction - 返されるセグメント(nullでもかまいません)に関連付けるカスタム・クリーンアップ・アクション。
  
  戻り値:
  
  指定されたアドレス、サイズ、およびスコープを持つネイティブ・セグメント。
  
  例外:
  
  IllegalArgumentException - byteSize < 0の場合。
  
  IllegalStateException - scopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope.isAccessibleBy(T) == falseなど)。
  
  IllegalCallerException - 呼び出し元が、ネイティブ・アクセスが有効になっていないモジュール内にある場合。
- allocateNative
  
  static MemorySegment^PREVIEW allocateNative(MemoryLayout^PREVIEW layout, SegmentScope^PREVIEW scope)
  指定されたレイアウトおよびスコープでネイティブ・セグメントを作成します。
  返されたネイティブ・セグメントに関連付けられたメモリーのライフ・タイム・オフ・ヒープ・リージョンは、指定されたスコープによって決まります。オフ・ヒープ・メモリー・リージョンは、スコープがalive^PREVIEWではなくなると割当て解除されます。 Arena^PREVIEWを使用してスコープが取得された場合、クライアントは、返されたセグメントが使用されなくなったときにアリーナが閉じられるようにする必要があります。そうしないと、オフ・ヒープ・メモリー・リークが発生します。もう1つの方法として、「自動スコープ」^PREVIEWを使用すると、戻されたネイティブ・セグメントに関連付けられたオフ・ヒープ・メモリー・リージョンを、スコープが参照されなくなった後で不特定の時間に自動的に解放できます。
  返されるメモリー・セグメントのaddressは、セグメントを支える新しく割り当てられたオフ・ヒープ・リージョンの開始アドレスです。さらに、返されるセグメントのaddressは、指定されたレイアウトの整列制約に従って整列されます。
  これは次のコードと等価です。
  
  allocateNative(layout.bytesSize(), layout.bytesAlignment(), scope);
  
  返されるネイティブ・セグメントを支えるオフ・ヒープ・リージョンのリージョンはゼロに初期化されます。
  パラメータ:
  
  layout - ネイティブ・セグメントを支えるオフ・ヒープ・メモリー・リージョンのレイアウト。
  
  scope - 返されるネイティブ・セグメントに関連付けられたスコープ。
  
  戻り値:
  
  新しいネイティブ・セグメント。
  
  例外:
  
  IllegalStateException - scopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope.isAccessibleBy(T) == falseなど)。
- allocateNative
  
  static MemorySegment^PREVIEW allocateNative(long byteSize, SegmentScope^PREVIEW scope)
  指定されたサイズ(バイト単位)およびスコープでネイティブ・セグメントを作成します。
  返されたネイティブ・セグメントに関連付けられたメモリーのライフ・タイム・オフ・ヒープ・リージョンは、指定されたスコープによって決まります。オフ・ヒープ・メモリー・リージョンは、スコープがalive^PREVIEWではなくなると割当て解除されます。 Arena^PREVIEWを使用してスコープが取得された場合、クライアントは、返されたセグメントが使用されなくなったときにアリーナが閉じられるようにする必要があります。そうしないと、オフ・ヒープ・メモリー・リークが発生します。もう1つの方法として、「自動スコープ」^PREVIEWを使用すると、戻されたネイティブ・セグメントに関連付けられたオフ・ヒープ・メモリー・リージョンを、スコープが参照されなくなった後で不特定の時間に自動的に解放できます。
  返されるメモリー・セグメントのaddressは、セグメントを支える新しく割り当てられたオフ・ヒープ・リージョンの開始アドレスです。さらに、返されるセグメントのaddressが少なくとも1バイトの整列であることが保証されます。
  これは次のコードと等価です。
  
  allocateNative(bytesSize, 1, scope);
  
  返されるネイティブ・セグメントを支えるオフ・ヒープ・リージョンのリージョンはゼロに初期化されます。
  パラメータ:
  
  byteSize - ネイティブ・メモリー・セグメントをバッキングするメモリーのオフ・ヒープ・メモリー・リージョンのサイズ(バイト単位)。
  
  scope - 返されるネイティブ・セグメントに関連付けられたスコープ。
  
  戻り値:
  
  新しいネイティブ・メモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - byteSize < 0の場合。
  
  IllegalStateException - scopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope.isAccessibleBy(T) == falseなど)。
- allocateNative
  
  static MemorySegment^PREVIEW allocateNative(long byteSize, long byteAlignment, SegmentScope^PREVIEW scope)
  
  指定されたサイズ(バイト単位)、整列(バイト単位)およびスコープでネイティブ・セグメントを作成します。
  返されたネイティブ・セグメントに関連付けられたメモリーのライフ・タイム・オフ・ヒープ・リージョンは、指定されたスコープによって決まります。オフ・ヒープ・メモリー・リージョンは、スコープがalive^PREVIEWではなくなると割当て解除されます。 Arena^PREVIEWを使用してスコープが取得された場合、クライアントは、返されたセグメントが使用されなくなったときにアリーナが閉じられるようにする必要があります。そうしないと、オフ・ヒープ・メモリー・リークが発生します。もう1つの方法として、「自動スコープ」^PREVIEWを使用すると、戻されたネイティブ・セグメントに関連付けられたオフ・ヒープ・メモリー・リージョンを、スコープが参照されなくなった後で不特定の時間に自動的に解放できます。
  返されるメモリー・セグメントのaddressは、セグメントを支える新しく割り当てられたオフ・ヒープ・リージョンの開始アドレスです。さらに、返されたセグメントのaddressは、指定された整列制約に従って整列されます。
  返されるネイティブ・セグメントを支えるオフ・ヒープ・リージョンのリージョンはゼロに初期化されます。
  
  パラメータ:
  
  byteSize - ネイティブ・メモリー・セグメントをバッキングするメモリーのオフ・ヒープ・リージョンのサイズ(バイト単位)。
  
  byteAlignment - ネイティブ・メモリー・セグメントをバッキングするメモリーのオフ・ヒープ・リージョンの境界整列制約 (バイト単位)。
  
  scope - 返されるネイティブ・セグメントに関連付けられたスコープ。
  
  戻り値:
  
  新しいネイティブ・メモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - byteSize < 0、byteAlignment <= 0またはbyteAlignmentが2の累乗でない場合。
  
  IllegalStateException - scopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope.isAccessibleBy(T) == falseなど)。
- 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.scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment.scope().isAccessibleBy(T) == falseなど)。
  
  IndexOutOfBoundsException - srcOffset + bytes > srcSegment.byteSize()またはdstOffset + bytes > dstSegment.byteSize()の場合、またはsrcOffset、dstOffsetまたはbytesのいずれかが< 0の場合。
  
  UnsupportedOperationException - 宛先セグメントが読取り専用(isReadOnly()を参照してください)の場合。
- 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().scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment().scope().isAccessibleBy(T) == falseなど)。
  
  IndexOutOfBoundsException - srcOffset + (elementCount * S) > srcSegment.byteSize()の場合、またはdstOffset + (elementCount * S) > dstSegment.byteSize()の場合(Sは要素レイアウトのバイト・サイズ、またはsrcOffset、dstOffsetまたはelementCountのいずれかが< 0の場合)。
  
  UnsupportedOperationException - 宛先セグメントが読取り専用(isReadOnly()を参照してください)の場合。
- get
  
  default byte get(ValueLayout.OfByte^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからバイトを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたバイト値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfByte^PREVIEW layout, long offset, byte value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにバイトを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるbyte値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default boolean get(ValueLayout.OfBoolean^PREVIEW layout, long offset)
  
  指定されたオフセットを使用して、このセグメントからブールを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたブール値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfBoolean^PREVIEW layout, long offset, boolean value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにブール値を書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるブール値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default char get(ValueLayout.OfChar^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからcharを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られる文字値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfChar^PREVIEW layout, long offset, char value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントに文字を書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるchar値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default short get(ValueLayout.OfShort^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからshortを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた短い値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfShort^PREVIEW layout, long offset, short value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにshortを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるshort値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default int get(ValueLayout.OfInt^PREVIEW layout, long offset)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからintを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたint値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfInt^PREVIEW layout, long offset, int value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにintを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるint値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default float get(ValueLayout.OfFloat^PREVIEW layout, long offset)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからフロートを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた浮動小数点値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfFloat^PREVIEW layout, long offset, float value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにフロートを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるfloat値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default long get(ValueLayout.OfLong^PREVIEW layout, long offset)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントからlongを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた長い値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfLong^PREVIEW layout, long offset, long value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにlongを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるlong値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default double get(ValueLayout.OfDouble^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントから倍精度浮動小数点数を読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られた二重値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfDouble^PREVIEW layout, long offset, double value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにdoubleを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるdouble値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- get
  
  default MemorySegment^PREVIEW get(ValueLayout.OfAddress^PREVIEW layout, long offset)
  
  指定されたレイアウトで、指定されたオフセットでこのセグメントからアドレスを読み取ります。読取りアドレスは、「グローバル・スコープ」^PREVIEWに関連付けられたネイティブ・セグメントにラップされます。通常の状況では、返されるセグメントのサイズは0です。ただし、指定されたレイアウトが「制限なし」^PREVIEWアドレス・レイアウトの場合、返されるセグメントのサイズはLong.MAX_VALUEです。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  戻り値:
  
  このセグメントから読み取られたアドレスをラップするネイティブ・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- set
  
  default void set(ValueLayout.OfAddress^PREVIEW layout, long offset, MemorySegment^PREVIEW value)
  
  指定されたレイアウトを使用して、指定されたオフセットでこのセグメントにアドレスを書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  offset - このアクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセット。
  
  value - 書き込まれるアドレス値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
  
  UnsupportedOperationException - valueが「ネイティブ」セグメントでない場合。
- getAtIndex
  
  default char getAtIndex(ValueLayout.OfChar^PREVIEW layout, long index)
  
  指定された索引のこのセグメントから、指定されたレイアウト・サイズで拡大縮小されたcharを読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られる文字値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default float getAtIndex(ValueLayout.OfFloat^PREVIEW layout, long index)
  
  指定された索引のこのセグメントからフロートを読み取り、指定されたレイアウト・サイズでスケールします。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られた浮動小数点値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default double getAtIndex(ValueLayout.OfDouble^PREVIEW layout, long index)
  
  指定された索引で、指定されたレイアウト・サイズで倍精度浮動小数点数を読み取ります。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られた二重値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- 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から呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
- getAtIndex
  
  default MemorySegment^PREVIEW getAtIndex(ValueLayout.OfAddress^PREVIEW layout, long index)
  
  指定されたインデックスの指定されたセグメントからアドレスを読み取り、指定されたレイアウト・サイズでスケーリングします。読取りアドレスは、「グローバル・スコープ」^PREVIEWに関連付けられたネイティブ・セグメントにラップされます。通常の状況では、返されるセグメントのサイズは0です。ただし、指定されたレイアウトが「制限なし」^PREVIEWアドレス・レイアウトの場合、返されるセグメントのサイズはLong.MAX_VALUEです。
  
  パラメータ:
  
  layout - 読み取るメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  戻り値:
  
  このセグメントから読み取られたアドレスをラップするネイティブ・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
- setAtIndex
  
  default void setAtIndex(ValueLayout.OfAddress^PREVIEW layout, long index, MemorySegment^PREVIEW value)
  
  指定された索引で、指定されたレイアウト・サイズでスケールされたアドレスをこのセグメントに書き込みます。
  
  パラメータ:
  
  layout - 書き込まれるメモリー・リージョンのレイアウト。
  
  index - 論理索引。アクセス操作が発生するバイト(このセグメント住所に対する相対)のオフセットは、(index * layout.byteSize())として表すことができます。
  
  value - 書き込まれるアドレス値。
  
  例外:
  
  IllegalStateException - このセグメントに関連付けられているscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(scope().isAccessibleBy(T) == falseなど)。
  
  IllegalArgumentException - 指定されたレイアウトでアクセス操作が「線形制約と互換性がありません」の場合、またはレイアウトの整列がそのサイズより大きい場合。
  
  IndexOutOfBoundsException - アクセス操作がメモリー・セグメントの「空間境界」の範囲外になった場合。
  
  UnsupportedOperationException - このセグメントがread-onlyの場合。
  
  UnsupportedOperationException - valueが「ネイティブ」セグメントでない場合。
- equals
  
  boolean equals(Object that)
  指定されたオブジェクトをこのメモリー・セグメントと比較し、等しいかどうかを調べます。指定されたオブジェクトがメモリー・セグメントでもある場合、および2つのセグメントが同じロケーションを参照する場合にのみ、メモリーの一部のリージョンでtrueを返します。具体的には、2つのセグメントs1とs2を等しいとみなす場合、次のすべてがtrueである必要があります:
  
  s1.array().equals(s2.array())。つまり、2つのセグメントが同じ種類である必要があります。どちらも「ネイティブ・セグメント」で、オフ・ヒープ・メモリーによってバックアップされるか、または両方が同じオン・ヒープJava配列によってバックアップされます
  s1.address() == s2.address()。つまり、2つのセグメントのアドレスは同じである必要があります。つまり、2つのセグメントは、一部のオフ・ヒープ・リージョン内の同じロケーションを参照するか、関連付けられたJava配列インスタンス内の同じロケーションを参照します。
  オーバーライド:
  
  equals、クラスObject
  
  APIのノート:
  
  このメソッドでは、2つのメモリー・セグメントの内容の構造比較は実行されません。クライアントは、かわりにmismatch(MemorySegment)メソッドを使用してメモリー・セグメントを構造的に比較できます。このメソッドは、2つのセグメントの一時的および空間的な境界を比較しません。そのため、ネイティブ・セグメントにNULLアドレスがあるかどうかの確認など、アドレス・チェックの実行に適しています。
  
  パラメータ:
  
  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が配列でない場合、または配列であるが型がサポートされていない場合、宛先配列コンポーネント・タイプがソース要素レイアウトのキャリアと一致しない場合、ソース要素レイアウトのソース・セグメント/オフセットが「線形制約と互換性がありません」である場合、または宛先要素のレイアウト整列がそのサイズより大きい場合。
- 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が配列でない場合、または配列であるが型がサポートされていない場合、ソース配列コンポーネント・タイプが宛先要素レイアウトのキャリアと一致しない場合、宛先要素レイアウトで宛先セグメント/オフセットが「線形制約と互換性がありません」である場合、または宛先要素レイアウトの配置がそのサイズより大きい場合。
- 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.scope().isAccessibleBy(T) == falseなど)。
  
  IllegalStateException - dstSegmentに関連付けられたscopeがalive^PREVIEWでない場合。
  
  WrongThreadException - このメソッドがスレッドTから呼び出された場合(dstSegment.scope().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[]`	`1`
`byte[]`	`1`
`char[]`	`2`
`short[]`	`2`
`int[]`	`4`
`float[]`	`4`
`long[]`	`8`
`double[]`	`8`

インタフェースMemorySegment

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

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

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

位置合せ

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

フィールドのサマリー

メソッドのサマリー

ﾌｨｰﾙﾄﾞ詳細

NULL

メソッドの詳細

address

array

spliterator

elements

scope

byteSize

asSlice

asSlice

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

ofAddress

ofAddress

ofAddress

allocateNative

allocateNative

allocateNative

copy

copy

get

set

get

set

get

set

get

set

get

set

get

set

get

set

get

set

get

set

getAtIndex

setAtIndex

getAtIndex