MethodHandle.AsSpreader 方法

定義

命名空間:: Java.Lang.Invoke

組件:: Mono.Android.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

多載

名稱	Description
AsSpreader(Class, Int32)	製作一個 <em>陣列擴展</em> 方法的handle，接受後方陣列參數，並將其元素擴展為位置參數。
AsSpreader(Int32, Class, Int32)	製作一個 <em>陣列擴展</em> 方法的 handle，能在指定位置接受陣列參數，並將其元素以位置參數形式分散，取代陣列。

AsSpreader(Class, Int32)

製作一個 陣列擴展 方法的handle，接受後方陣列參數，並將其元素擴展為位置參數。

[Android.Runtime.Register("asSpreader", "(Ljava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_Ljava_lang_Class_IHandler", ApiSince=26)]
public virtual Java.Lang.Invoke.MethodHandle? AsSpreader(Java.Lang.Class? arrayType, int arrayLength);

[<Android.Runtime.Register("asSpreader", "(Ljava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_Ljava_lang_Class_IHandler", ApiSince=26)>]
abstract member AsSpreader : Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle
override this.AsSpreader : Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle

參數

arrayType: Class

通常 Object[]，從中提取擴散參數的陣列參數類型

arrayLength: Int32

從一個進入陣列參數中要擴散的參數數量

傳回

MethodHandle

一個新的方法句柄，該處理者會先展開其最後的陣列參數，然後再呼叫原始方法的句柄

屬性: RegisterAttribute

備註

製作一個 陣列擴展 方法的handle，接受後方陣列參數，並將其元素擴展為位置參數。新方法的 handle 會以現有的方法 handle 作為 其目標。適配器的類型與目標的類型相同，但目標類型的最終 arrayLength 參數被一個類型的 arrayType單一陣列參數取代。

若陣列元素類型與原始目標上任何對應參數類型不同，原始目標會被調整為直接取組列元素，就像呼叫。#asType asType

當被呼叫時，介面卡會將後方陣列的參數替換為陣列的元素，每個元素作為對目標的獨立參數。（論證的順序保留。）它們會透過鑄造和/或開箱成對轉換成目標的尾隨參數類型。最後，目標被叫到。目標最終回傳的訊號會被轉接器不做更改地回傳。

在呼叫目標器之前，介面卡會驗證陣列中剛好包含足夠的元素，以提供正確的參數數量給目標方法的句柄。（當需要零元素時，陣列也可能為空。）

當呼叫介面卡時，會以位元組碼的方式查詢array.lengtharraylength所提供array參數的長度。若適配器接受零長度的尾隨陣列參數，所提供的 array 參數可以是零長度陣列，或 null;否則，若陣列為，則拋出 a NullPointerException ;若陣列元素 null 數不正確，則拋出 a IllegalArgumentException 。

以下是一些簡單的陣列擴展方法句柄範例： <blockquote>

{@code
            MethodHandle equals = publicLookup()
              .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
            assert( (boolean) equals.invokeExact("me", (Object)"me"));
            assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
            // spread both arguments from a 2-array:
            MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
            assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
            assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
            // try to spread from anything but a 2-array:
            for (int n = 0; n <= 10; n++) {
              Object[] badArityArgs = (n == 2 ? new Object[0] : new Object[n]);
              try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
              catch (IllegalArgumentException ex) { } // OK
            }
            // spread both arguments from a String array:
            MethodHandle eq2s = equals.asSpreader(String[].class, 2);
            assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
            assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
            // spread second arguments from a 1-array:
            MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
            assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
            assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
            // spread no arguments from a 0-array or null:
            MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
            assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
            assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
            // asSpreader and asCollector are approximate inverses:
            for (int n = 0; n <= 2; n++) {
                for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
                    MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
                    assert( (boolean) equals2.invokeWithArguments("me", "me"));
                    assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
                }
            }
            MethodHandle caToString = publicLookup()
              .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
            assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
            MethodHandle caString3 = caToString.asCollector(char[].class, 3);
            assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
            MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
            assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));
            }

</區塊引用>

的 java.lang.invoke.MethodHandle.asSpreader(java.lang.Class<?>, int)Java 檔。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

AsSpreader(Int32, Class, Int32)

製作一個 陣列擴展 方法的 handle，能在指定位置接受陣列參數，並將其元素以位置參數形式分散，取代陣列。

[Android.Runtime.Register("asSpreader", "(ILjava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_ILjava_lang_Class_IHandler", ApiSince=33)]
public virtual Java.Lang.Invoke.MethodHandle? AsSpreader(int spreadArgPos, Java.Lang.Class? arrayType, int arrayLength);

[<Android.Runtime.Register("asSpreader", "(ILjava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_ILjava_lang_Class_IHandler", ApiSince=33)>]
abstract member AsSpreader : int * Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle
override this.AsSpreader : int * Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle

參數

spreadArgPos: Int32

參數列表中應該開始擴張的位置（以零為基礎的索引）。

arrayType: Class

通常 Object[]，從中提取擴散參數的陣列參數類型

arrayLength: Int32

從一個進入陣列參數中要擴散的參數數量

傳回

MethodHandle

一個新的方法處理柄，會在指定位置展開一個陣列參數，然後再呼叫原始方法處理

屬性: RegisterAttribute

備註

製作一個 陣列擴展 方法的 handle，能在指定位置接受陣列參數，並將其元素以位置參數形式分散，取代陣列。新方法的 handle 會以現有的方法 handle 作為 其目標。適配器的類型與目標的類型相同，但 arrayLength 目標類型從零點位置 spreadArgPos開始的參數被一個類型 arrayType為的單一陣列參數取代。

此方法的行為非常類似 #asSpreader(Class, int)，但接受額外 spreadArgPos 參數以指示參數列表中擴散應在哪個位置進行。

新增9。

的 java.lang.invoke.MethodHandle.asSpreader(int, java.lang.Class<?>, int)Java 檔。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於