public sealed interface MemorySegment

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

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

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

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

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

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

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

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

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

すべてのメモリー・セグメントには、long値として表される「最大バイト整列」があります。詳細は、belowを参照してください。最大整列は、セグメント・アドレスとセグメント・タイプから派生した2の累乗です。

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

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

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

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

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

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

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

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

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

メモリー・セグメントに対するアクセス操作は、varハンドルを使用して実装されます。 ValueLayout.varHandle()メソッドを使用すると、指定されたオフセットにあるメモリー・セグメントの指定された値レイアウトによって表される値を取得/設定するために使用できるvarハンドルを取得できます。

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

または、特定の論理索引でint配列の要素にアクセスするために使用できるvarハンドルを、次のように作成できます。

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

クライアントは、アクセス式をよりシンプルにするために、ベース・オフセット・パラメータを削除することもできます。これは、getAtIndex(OfInt, long)などのアクセス操作の実装に使用できます。

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

より複雑なアクセス式の変数ハンドル(例:構造体フィールド・アクセス、ポインタ間接参照)は、「レイアウト・パス」を使用して、メモリー・レイアウトから直接作成できます。

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

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

 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値を読み取ろうとすると例外が発生します。元のセグメントの「一時的な境界」は、そのスライスによって継承されます。つまり、segmentに関連付けられたスコープがaliveでなくなると、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)またはSegmentAllocator.allocate(MemoryLayout)のいずれかを使用して、8バイトの整列制約を指定してセグメントを割り当てる必要があります。これらのファクトリは、返されるセグメントを裏付けるメモリーのオフ・ヒープ・リージョンに、8バイトの整列された開始アドレスがあることを確認します。その後、プログラマは関心のある相殺でセグメントにアクセスできます -- 0、8、16、24など -- そのようなすべてのアクセスが合致しているという知識。

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

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

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[]配列の開始物理アドレスは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などでセグメントにアクセスできます。

つまり、ヒープ・セグメントには、次の表に示すように、セグメントを支えるJava配列の要素のサイズから導出される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.JAVA_LONG.byteAlignment() (8バイト)に設定されます:

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

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

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

クライアントは、次のようにmaxByteAlignment()メソッドを使用して、メモリー・セグメントがメモリー・レイアウトの配置制約をサポートしているかどうかを確認できます:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ネストされたクラス

修飾子と型

インタフェース

説明

static interface

MemorySegment.Scope

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

フィールド

修飾子と型

フィールド

説明

static final MemorySegment

NULL

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

修飾子と型

メソッド

説明

long

address()

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

ByteBuffer

asByteBuffer()

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

Optional<MemorySegment>

asOverlappingSlice(MemorySegment other)

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

MemorySegment

asReadOnly()

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

MemorySegment

asSlice(long offset)

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

MemorySegment

asSlice(long offset, long newSize)

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

MemorySegment

asSlice(long offset, long newSize, long byteAlignment)

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

MemorySegment

asSlice(long offset, MemoryLayout layout)

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

long

byteSize()

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

static void

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

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

static void

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

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

static void

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

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

static void

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

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

MemorySegment

copyFrom(MemorySegment src)

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

Stream<MemorySegment>

elements(MemoryLayout elementLayout)

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

boolean

equals(Object that)

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

MemorySegment

fill(byte value)

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

void

force()

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

MemorySegment

get(AddressLayout layout, long offset)

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

boolean

get(ValueLayout.OfBoolean layout, long offset)

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

byte

get(ValueLayout.OfByte layout, long offset)

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

char

get(ValueLayout.OfChar layout, long offset)

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

double

get(ValueLayout.OfDouble layout, long offset)

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

float

get(ValueLayout.OfFloat layout, long offset)

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

int

get(ValueLayout.OfInt layout, long offset)

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

long

get(ValueLayout.OfLong layout, long offset)

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

short

get(ValueLayout.OfShort layout, long offset)

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

MemorySegment

getAtIndex(AddressLayout layout, long index)

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

boolean

getAtIndex(ValueLayout.OfBoolean layout, long index)

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

byte

getAtIndex(ValueLayout.OfByte layout, long index)

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

char

getAtIndex(ValueLayout.OfChar layout, long index)

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

double

getAtIndex(ValueLayout.OfDouble layout, long index)

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

float

getAtIndex(ValueLayout.OfFloat layout, long index)

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

int

getAtIndex(ValueLayout.OfInt layout, long index)

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

long

getAtIndex(ValueLayout.OfLong layout, long index)

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

short

getAtIndex(ValueLayout.OfShort layout, long index)

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

String

getString(long offset)

UTF-8文字セットを使用して、指定されたオフセットでこのセグメントからNULLで終了する文字列を読み取ります。

String

getString(long offset, Charset charset)

指定された文字セットを使用して、指定されたオフセットでこのセグメントから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()

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

long

maxByteAlignment()

このメモリー・セグメントに関連付けられた「最大バイト整列」を返します。

long

mismatch(MemorySegment other)

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

static long

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

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

static MemorySegment

ofAddress(long address)

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

static MemorySegment

ofArray(byte[] byteArray)

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

static MemorySegment

ofArray(char[] charArray)

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

static MemorySegment

ofArray(double[] doubleArray)

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

static MemorySegment

ofArray(float[] floatArray)

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

static MemorySegment

ofArray(int[] intArray)

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

static MemorySegment

ofArray(long[] longArray)

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

static MemorySegment

ofArray(short[] shortArray)

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

static MemorySegment

ofBuffer(Buffer buffer)

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

MemorySegment

reinterpret(long newSize)

Restricted.

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

MemorySegment

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

Restricted.

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

MemorySegment

reinterpret(Arena arena, Consumer<MemorySegment> cleanup)

Restricted.

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

MemorySegment.Scope

scope()

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

void

set(AddressLayout layout, long offset, MemorySegment value)

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

setAtIndex(AddressLayout layout, long index, MemorySegment value)

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

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

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

void

setString(long offset, String str)

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

void

setString(long offset, String str, Charset charset)

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

Spliterator<MemorySegment>

spliterator(MemoryLayout elementLayout)

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

byte[]

toArray(ValueLayout.OfByte elementLayout)

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

char[]

toArray(ValueLayout.OfChar elementLayout)

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

double[]

toArray(ValueLayout.OfDouble elementLayout)

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

float[]

toArray(ValueLayout.OfFloat elementLayout)

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

int[]

toArray(ValueLayout.OfInt elementLayout)

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

long[]

toArray(ValueLayout.OfLong elementLayout)

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

short[]

toArray(ValueLayout.OfShort elementLayout)

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

void

unload()

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

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

maxByteAlignment

asSlice

asSlice

asSlice

asSlice

reinterpret

reinterpret

reinterpret

isReadOnly

asReadOnly

isNative

isMapped

asOverlappingSlice

fill

copyFrom

mismatch

isLoaded

load

unload

force

asByteBuffer

toArray

toArray

toArray

toArray

toArray

toArray

toArray

getString

getString

setString

setString

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