MethodHandles.IteratedLoop(MethodHandle, MethodHandle, MethodHandle) Méthode

[Android.Runtime.Register("iteratedLoop", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=33)]
public static Java.Lang.Invoke.MethodHandle? IteratedLoop(Java.Lang.Invoke.MethodHandle? iterator, Java.Lang.Invoke.MethodHandle? init, Java.Lang.Invoke.MethodHandle? body);

[<Android.Runtime.Register("iteratedLoop", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=33)>]
static member IteratedLoop : Java.Lang.Invoke.MethodHandle * Java.Lang.Invoke.MethodHandle * Java.Lang.Invoke.MethodHandle -> Java.Lang.Invoke.MethodHandle

Paramètres

Retours

un handle de méthode qui incarne la fonctionnalité de boucle d’itération.

Attributs

RegisterAttribute

Remarques

Construit une boucle qui s’étend sur les valeurs produites par un Iterator<T>. Il s’agit d’un wrapper pratique pour le combinateur de boucle générique #loop(MethodHandle[][]).

L’itérateur lui-même sera déterminé par l’évaluation du iterator handle. Chaque valeur produite est stockée dans une variable d’itération de boucle de type T.

Si le body handle retourne un non-typeVvoid, une variable d’itération de boucle de début de ce type est également présente. Cette variable est initialisée à l’aide du handle facultatif init ou à l'#empty valeur par défaut de type V si ce handle est null.

Dans chaque itération, les variables d’itération sont passées à un appel du body handle. Une valeur nonvoid renvoyée par le corps (de type V) met à jour la variable d’itération principale. Le résultat de l’exécution du handle de boucle est la valeur finale V de cette variable (ou void s’il n’y a pas V de variable).

Les règles suivantes sont conservées pour les handles d’argument :ul>li Le handle ne doit pas être null; son type doit être de la forme (V T A...)V, où V n’estvoid pas, ou sinon (T A...)void.body><< (Dans le void cas, nous affectons le type void au nomV, et nous allons écrire (V T A...)V avec la compréhension qu’un void type V est tranquillement supprimé de la liste des paramètres, en laissant (T A...)V.) <li>La liste (V T A...) des paramètres du corps contribue à une liste de types appelés em <>internal parameter list</em>. Elle limite les listes de paramètres des autres parties de boucle. <li>As a special case, if the body contribution only V and T types, with no additional A types, then the internal parameter list is extended by the argument types A... of the iterator handle ; if it is null the single type Iterable is added and constitue la A... liste. <li>Si les types (V T) de variables d’itération sont supprimés de la liste de paramètres internes, la liste (A...) plus courte résultante est appelée liste<<> de paramètres externes em.> <li>Le type Vde retour du corps, s’il n’est pas levoid cas, détermine le type d’une variable d’état supplémentaire de la boucle. Le corps doit accepter un paramètre de début et retourner une valeur de ce type V. <li>If init is non-null, it must have return type V. Sa liste de paramètres (de la forme <c(A*)</c>) doit être effectivement identique à la liste de (A...)paramètres> externes. <li>If init is null, la variable de boucle est initialisée à sa valeur par défaut #empty. <li>Si le iterator handle n’est pas,null il doit avoir le type java.util.Iterator de retour ou un sous-type de celui-ci. L’itérateur qu’il produit lorsque la boucle est exécutée est supposée générer des valeurs qui peuvent être converties en type T. <li>La liste de paramètres d’un iterator paramètre qui n’est pasnull (d’une certaine forme (A*)) doit être effectivement identique à la liste de (A...)paramètres externes . <li>If iterator est-il null défini par défaut sur un handle de méthode qui se comporte comme java.lang.Iterable#iterator(). Dans ce cas, la liste (V T A...) de paramètres internes doit avoir au moins un A type et le paramètre de handle d’itérateur par défaut est ajusté pour accepter le type de début A , comme si par la MethodHandle#asType asType méthode de conversion. Le type de début A doit être Iterable ou un sous-type de celui-ci. Cette étape de conversion, effectuée au moment de la construction de boucles, ne doit pas lever un WrongMethodTypeException. </ul>

Le type T peut être une primitive ou une référence. Étant donné que le type Iterator<T> est effacé dans la représentation de handle de méthode au type Iteratorbrut, le iteratedLoop combinateur ajuste le type d’argument de début comme bodyObject si par la MethodHandle#asType asType méthode de conversion. Par conséquent, si un itérateur du type incorrect apparaît lorsque la boucle est exécutée, les exceptions d’exécution peuvent se produire en raison de conversions dynamiques effectuées par MethodHandle#asType(MethodType).

Le type de résultat et la signature de paramètre du handle de boucle résultant sont déterminés comme suit :< ul<>li>Le type de résultat du handle de boucle est le type V de résultat du corps. <li>Les types de paramètres du handle de boucle sont les types (A...), à partir de la liste de paramètres externes. </ul>

Voici le pseudocode pour le handle de boucle résultant. Dans le code, Vv/représente le type /valeur de la variable de boucle ainsi que le type de résultat de la boucle ;/Tt , celui des éléments de la structure sur lequel la boucle itère et A.../a... représente les arguments passés à la boucle. <blockquote>

{@code
            Iterator<T> iterator(A...);  // defaults to Iterable::iterator
            V init(A...);
            V body(V,T,A...);
            V iteratedLoop(A... a...) {
              Iterator<T> it = iterator(a...);
              V v = init(a...);
              while (it.hasNext()) {
                T t = it.next();
                v = body(v, t, a...);
              }
              return v;
            }
            }

</blockquote>

Ajouté dans 9.

Java documentation pour java.lang.invoke.MethodHandles.iteratedLoop(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.