MethodHandle.AsVarargsCollector(Class) Methode

[Android.Runtime.Register("asVarargsCollector", "(Ljava/lang/Class;)Ljava/lang/invoke/MethodHandle;", "GetAsVarargsCollector_Ljava_lang_Class_Handler", ApiSince=26)]
public virtual Java.Lang.Invoke.MethodHandle? AsVarargsCollector(Java.Lang.Class? arrayType);

[<Android.Runtime.Register("asVarargsCollector", "(Ljava/lang/Class;)Ljava/lang/invoke/MethodHandle;", "GetAsVarargsCollector_Ljava_lang_Class_Handler", ApiSince=26)>]
abstract member AsVarargsCollector : Java.Lang.Class -> Java.Lang.Invoke.MethodHandle
override this.AsVarargsCollector : Java.Lang.Class -> Java.Lang.Invoke.MethodHandle

Parameter

Gibt zurück

ein neues Methodenhandle, mit dem eine beliebige Anzahl von nachgestellten Argumenten in einem Array gesammelt werden kann, bevor das ursprüngliche Methodenhandle aufgerufen wird

Attribute

RegisterAttribute

Hinweise

Macht einen <Em-Variablen-Arity></em-Adapter>, der eine beliebige Anzahl von nachfolgenden Positionsargumenten akzeptieren und in einem Arrayargument sammeln kann.

Der Typ und das Verhalten des Adapters entsprechen dem Typ und Verhalten des Ziels, mit der Ausnahme, dass bestimmte invoke und asType Anforderungen zu nachgestellten Positionsargumenten führen können, die im nachgestellten Parameter des Ziels erfasst werden. Außerdem lautet arrayTypeder letzte Parametertyp "MethodType#lastParameterType" des Adapters , auch wenn das Ziel einen anderen letzten Parametertyp aufweist.

Diese Transformation kann zurückgegeben werden this , wenn das Methodenhandle bereits variabler Arität ist und der nachfolgende Parametertyp identisch arrayTypeist.

Wenn der Adapter mit #invokeExact invokeExactdem Aufruf aufgerufen wird, ruft der Adapter das Ziel ohne Argumentänderungen auf. (<em>Hinweis:</em> Dieses Verhalten unterscheidet sich von einem #asCollector festen Aritysammler, da es ein ganzes Array unbestimmter Länge anstelle einer festen Anzahl von Argumenten akzeptiert.)

Wenn der Aufrufertyp mit einfachem, inexact #invoke invokeaufgerufen wird, wenn der Aufrufertyp mit dem Adapter identisch ist, ruft der Adapter das Ziel wie bei invokeExact. (Dies ist das normale Verhalten, invoke wenn Typen übereinstimmen.)

Andernfalls ist der Aufrufer und die Adapterarität identisch, und der nachfolgende Parametertyp des Aufrufers ist ein Verweistyp, der mit dem nachfolgenden Parametertyp des Adapters identisch oder zuzuweisen ist, werden die Argumente und Rückgabewerte paarweise konvertiert, als ob es sich bei einem Handle mit #asType asType einer festen Arity-Methode um ein Handle handelt.

Andernfalls unterscheiden sich die Aritäten, oder der nachfolgende Parametertyp des Adapters kann nicht vom entsprechenden Aufrufertyp zugewiesen werden. In diesem Fall ersetzt der Adapter alle nachgestellten Argumente von der ursprünglichen nachgestellten Argumentposition durch ein neues Array vom Typ arrayType, dessen Elemente (in der Reihenfolge) die ersetzten Argumente umfassen.

Der Aufrufertyp muss mindestens genügend Argumente und den richtigen Typ bereitstellen, um die Anforderung des Ziels für Positionsargumente vor dem nachfolgenden Arrayargument zu erfüllen. Daher muss der Aufrufer mindestens N-1 Argumente bereitstellen, wobei N die Arität des Ziels liegt. Außerdem müssen Konvertierungen aus den eingehenden Argumenten in die Argumente des Ziels vorhanden sein. Wie bei anderen Verwendungen von einfachem invoke, wenn diese Grundanforderungen nicht erfüllt sind, kann eine WrongMethodTypeException ausgelöst werden.

In allen Fällen wird, was das Ziel schließlich zurückgibt, vom Adapter unverändert zurückgegeben.

Im letzten Fall ist es genau so, als ob der Zielmethodenhandle vorübergehend mit einem #asCollector festen Aritätssammler an die vom Aufrufertyp erforderliche Arität angepasst wurde. (Wie bei asCollectorder Arraylänge null, kann anstelle eines neuen Arrays eine freigegebene Konstante verwendet werden. Wenn der implizite Aufruf asCollector einen IllegalArgumentException oder WrongMethodTypeExceptionmehrere Aufrufe auslösen würde, muss der Aufruf des Variablen-Arity-Adapters ausgelöst werden WrongMethodTypeException.)

Das Verhalten von #asType asType ist auch auf variablen Arity-Adapter spezialisiert, um die invariant, dass nur, inexact invoke ist immer gleichbedeutend mit einem asType Aufruf, um den Zieltyp anzupassen, gefolgt von invokeExact. Daher antwortet ein Variabler Arity-Adapter auf eine asType Anforderung, indem er einen festen Arity-Collector erstellt, wenn und nur, wenn der Adapter und der angeforderte Typ entweder in Arität oder nachgestelltem Argumenttyp unterschiedlich sind. Der resultierende Festarzsammler hat seinen Typ (falls erforderlich) weiter an den angeforderten Typ durch konvertierung paarweise angepasst, als wäre es durch eine andere Anwendung von asType.

Wenn ein Methodenhandle durch Ausführen einer Anweisung einer ldcCONSTANT_MethodHandle Konstante abgerufen wird und die Zielmethode als variable Arity-Methode (mit dem Modifiziererbit 0x0080) gekennzeichnet wird, akzeptiert der Methodenhandle mehrere Aritäten, als ob die Methodenhandle-Konstante mithilfe eines Aufrufs asVarargsCollectorerstellt wurde.

Um einen Sammlungsadapter zu erstellen, der eine vordefinierte Anzahl von Argumenten sammelt und deren Typ diese vordefinierte Zahl widerspiegelt, verwenden Sie #asCollector asCollector stattdessen.

Keine Methodenhandles erzeugen neue Methodenhandles mit variabler Arität, es sei denn, sie werden so dokumentiert. Daher geben alle Methoden MethodHandleMethodHandles außer asVarargsCollector den withVarargsFällen, in denen sie ihren ursprünglichen Operanden (z. asType B. den eigenen Typ des Methodenhandle) angeben, ein Methodenhandle mit fester Authentifizierung zurück.

Das Aufrufen asVarargsCollector eines Methodenhandles, das bereits variabler Arity ist, erzeugt ein Methodenhandle mit demselben Typ und Verhalten. Es kann (oder nicht) den ursprünglichen Ziehpunkt der Variablen arity-Methode zurückgeben.

Nachfolgend sehen Sie ein Beispiel für ein Handle für eine Listenerstellungsvariablen-Methode: <Blockquote>

{@code
            MethodHandle deepToString = publicLookup()
              .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
            MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class);
            assertEquals("[won]",   (String) ts1.invokeExact(    new Object[]{"won"}));
            assertEquals("[won]",   (String) ts1.invoke(         new Object[]{"won"}));
            assertEquals("[won]",   (String) ts1.invoke(                      "won" ));
            assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"}));
            // findStatic of Arrays.asList(...) produces a variable arity method handle:
            MethodHandle asList = publicLookup()
              .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
            assertEquals(methodType(List.class, Object[].class), asList.type());
            assert(asList.isVarargsCollector());
            assertEquals("[]", asList.invoke().toString());
            assertEquals("[1]", asList.invoke(1).toString());
            assertEquals("[two, too]", asList.invoke("two", "too").toString());
            String[] argv = { "three", "thee", "tee" };
            assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
            assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString());
            List ls = (List) asList.invoke((Object)argv);
            assertEquals(1, ls.size());
            assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));
            }

</blockquote>

<em>Discussion:</em> Diese Regeln sind als dynamisch typierte Variation der Java Regeln für variablen Aritätsmethoden konzipiert. In beiden Fällen können Aufrufer einer variablen Arity-Methode oder eines Methodenhandles entweder null oder mehr Positionsargumente übergeben oder zuvor gesammelte Arrays beliebiger Länge übergeben. Die Benutzer sollten sich der besonderen Rolle des endgültigen Arguments und der Auswirkung einer Typeinstimmung auf dieses abschließende Argument bewusst sein, die bestimmt, ob ein einzelnes nachfolgendes Argument als ganzes Array oder als einzelnes Element eines arrays interpretiert wird, das erfasst werden soll. Beachten Sie, dass der dynamische Typ des nachgestellten Arguments keine Auswirkungen auf diese Entscheidung hat, nur ein Vergleich zwischen dem symbolischen Typdeskriptor der Aufrufwebsite und dem Typdeskriptor des Methodenhandles.)

Java Dokumentation für java.lang.invoke.MethodHandle.asVarargsCollector(java.lang.Class<?>).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.