ICollector Interface
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Opération de réduction mutable qui accumule les éléments d’entrée dans un conteneur de résultats mutable, en transformant éventuellement le résultat cumulé en une représentation finale après le traitement de tous les éléments d’entrée.
[Android.Runtime.Register("java/util/stream/Collector", "", "Java.Util.Streams.ICollectorInvoker", ApiSince=24)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T", "A", "R" })]
public interface ICollector : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable[<Android.Runtime.Register("java/util/stream/Collector", "", "Java.Util.Streams.ICollectorInvoker", ApiSince=24)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T", "A", "R" })>]
type ICollector = interface
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Attributs
- Implémente
Remarques
Opération de réduction mutable qui accumule les éléments d’entrée dans un conteneur de résultats mutable, en transformant éventuellement le résultat cumulé en une représentation finale après le traitement de tous les éléments d’entrée. Les opérations de réduction peuvent être effectuées séquentiellement ou en parallèle.
Parmi les exemples d’opérations de réduction mutables, citons : accumulation d’éléments dans un Collection; concaténation de chaînes à l’aide d’un StringBuilder; calcul d’informations récapitulatives sur des éléments tels que somme, min, max, max ou moyenne ; calcul des résumés de « tableau croisé dynamique » tels que « transaction maximale évaluée par vendeur », etc. La classe Collectors fournit des implémentations de nombreuses réductions mutables courantes.
Un Collector est spécifié par quatre fonctions qui fonctionnent ensemble pour accumuler des entrées dans un conteneur de résultats mutable, et éventuellement effectuer une transformation finale sur le résultat. Ils sont : <création ul><li>d’un nouveau conteneur de résultats (#supplier())</li li>><incorporant un nouvel élément de données dans un conteneur de résultats (#accumulator())</li li>><combinant deux conteneurs de résultats en un (#combiner())</li li><>effectuant une transformation finale facultative sur le conteneur (#finisher())</li></ul>
Les collecteurs ont également un ensemble de caractéristiques, telles que Characteristics#CONCURRENT, qui fournissent des indicateurs qui peuvent être utilisés par une implémentation de réduction pour fournir de meilleures performances.
Une implémentation séquentielle d’une réduction à l’aide d’un collecteur créerait un conteneur de résultats unique à l’aide de la fonction fournisseur et appelait la fonction d’accumulation une fois pour chaque élément d’entrée. Une implémentation parallèle partitionne l’entrée, crée un conteneur de résultats pour chaque partition, accumule le contenu de chaque partition dans un sous-résultat pour cette partition, puis utilise la fonction de combinaison pour fusionner les sous-résultats dans un résultat combiné.
Pour garantir que les exécutions séquentielles et parallèles produisent des résultats équivalents, les fonctions du collecteur doivent satisfaire à une <identité< em>/em> et à des contraintes d’association.
La contrainte d’identité indique que pour tout résultat partiellement accumulé, la combinaison avec un conteneur de résultats vide doit produire un résultat équivalent. Autrement dit, pour un résultat a partiellement cumulé qui est le résultat d’une série d’appels d’accumulation et de combiner, a doit être équivalent à combiner.apply(a, supplier.get()).
La contrainte d’associativité indique que le fractionnement du calcul doit produire un résultat équivalent. Autrement dit, pour tous les éléments t1 d’entrée et t2, les résultats r1 et r2 dans le calcul ci-dessous doivent être équivalents :
{@code
A a1 = supplier.get();
accumulator.accept(a1, t1);
accumulator.accept(a1, t2);
R r1 = finisher.apply(a1); // result without splitting
A a2 = supplier.get();
accumulator.accept(a2, t1);
A a3 = supplier.get();
accumulator.accept(a3, t2);
R r2 = finisher.apply(combiner.apply(a2, a3)); // result with splitting
}
Pour les collecteurs qui n’ont pas la UNORDERED caractéristique, deux résultats a1 cumulés et a2 sont équivalents si finisher.apply(a1).equals(finisher.apply(a2)). Pour les collecteurs non ordonnés, l’équivalence est assouplie pour permettre une non-égalité liée aux différences dans l’ordre. (Par exemple, un collecteur non ordonné qui a accumulé des éléments à un List serait considéré comme deux listes équivalentes s’ils contenaient les mêmes éléments, ignorant l’ordre.)
Les bibliothèques qui implémentent la réduction basée surCollector, par exempleStream#collect(Collector), doivent respecter les contraintes suivantes : <ul><li>Le premier argument passé à la fonction d’accumulation, les deux arguments passés à la fonction de combinaison, et l’argument passé à la fonction finisher doit être le résultat d’un appel précédent du fournisseur de résultats, de l’accumulation ou des fonctions de combinaison.</li li><>L’implémentation ne doit rien faire avec le résultat de l’un des fournisseurs de résultats, de l’accumulation ou des fonctions de combinaison autres que de les transmettre à l’accumulateur, au combineur ou aux fonctions finisher, ou de les retourner à l’appelant de l’opération de réduction.</li li><>Si un résultat est passé à la fonction combiner ou finisher, et que le même objet n’est pas retourné par cette fonction, il n’est jamais utilisé à nouveau.</li li><>Une fois qu’un résultat est passé à la fonction combiner ou finisher, il n’est jamais passé à la fonction d’accumulation à nouveau.</li li><>Pour les collecteurs non simultanés, tout résultat retourné par le fournisseur de résultats, l’accumulation ou les fonctions de combinaison doivent être limités en série. Cela permet à la collecte de se produire en parallèle sans Collector avoir à implémenter une synchronisation supplémentaire. L’implémentation de réduction doit gérer que l’entrée est correctement partitionnée, que les partitions sont traitées séparément et que la combinaison se produit uniquement une fois l’accumulation terminée.</li li><>Pour les collecteurs simultanés, une implémentation est gratuite (mais pas nécessaire pour) implémenter la réduction simultanément. Une réduction simultanée est celle où la fonction d’accumulation est appelée simultanément à partir de plusieurs threads, en utilisant le même conteneur de résultats modifiable simultanément, plutôt que de conserver le résultat isolé pendant l’accumulation. Une réduction simultanée ne doit être appliquée que si le collecteur a les Characteristics#UNORDERED caractéristiques ou si les données d’origine ne sont pas ordonnées.</li></ul>
En plus des implémentations prédéfinies dans Collectors, les méthodes #of(Supplier, BiConsumer, BinaryOperator, Characteristics...) de fabrique statique peuvent être utilisées pour construire des collecteurs. Par exemple, vous pouvez créer un collecteur qui accumule des widgets dans un TreeSet avec :
{@code
Collector<Widget, ?, TreeSet<Widget>> intoSet =
Collector.of(TreeSet::new, TreeSet::add,
(left, right) -> { left.addAll(right); return left; });
}
(Ce comportement est également implémenté par le collecteur Collectors#toCollection(Supplier)prédéfini).
Ajouté dans la version 1.8.
Documentation Java pour java.util.stream.Collector.
Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.
Propriétés
| Handle |
Obtient la valeur JNI de l’objet Android sous-jacent. (Hérité de IJavaObject) |
| JniIdentityHashCode |
Retourne la valeur de |
| JniManagedPeerState |
État de l’homologue managé. (Hérité de IJavaPeerable) |
| JniPeerMembers |
Prise en charge de l’accès aux membres et de l’appel. (Hérité de IJavaPeerable) |
| PeerReference |
Retourne une JniObjectReference instance d’objet Java encapsulée. (Hérité de IJavaPeerable) |
Méthodes
| Accumulator() |
Fonction qui plie une valeur dans un conteneur de résultats mutable. |
| Characteristics() |
Retourne un |
| Combiner() |
Fonction qui accepte deux résultats partiels et les fusionne. |
| Disposed() |
Appelé lorsque l’instance a été supprimée. (Hérité de IJavaPeerable) |
| DisposeUnlessReferenced() |
S’il n’existe aucune référence en suspens à cette instance, les appels |
| Finalized() |
Appelé lorsque l’instance a été finalisée. (Hérité de IJavaPeerable) |
| Finisher() |
Effectuez la transformation finale du type |
| Of(ISupplier, IBiConsumer, IBinaryOperator, CollectorCharacteristics[]) |
Retourne un nouveau |
| Of(ISupplier, IBiConsumer, IBinaryOperator, IFunction, CollectorCharacteristics[]) |
Retourne un nouveau |
| SetJniIdentityHashCode(Int32) |
Définissez la valeur retournée par |
| SetJniManagedPeerState(JniManagedPeerStates) |
Opération de réduction mutable qui accumule les éléments d’entrée dans un conteneur de résultats mutable, en transformant éventuellement le résultat cumulé en une représentation finale après le traitement de tous les éléments d’entrée. (Hérité de IJavaPeerable) |
| SetPeerReference(JniObjectReference) |
Définissez la valeur retournée par |
| Supplier() |
Fonction qui crée et retourne un nouveau conteneur de résultats mutable. |
| UnregisterFromRuntime() |
Annulez l’inscription de cette instance afin que le runtime ne le retourne pas à partir d’appels futurs Java.Interop.JniRuntime+JniValueManager.PeekValue . (Hérité de IJavaPeerable) |
Méthodes d’extension
| JavaCast<TResult>(IJavaObject) |
Effectue une conversion de type vérifiée par le runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Opération de réduction mutable qui accumule les éléments d’entrée dans un conteneur de résultats mutable, en transformant éventuellement le résultat cumulé en une représentation finale après le traitement de tous les éléments d’entrée. |
| GetJniTypeName(IJavaPeerable) |
Opération de réduction mutable qui accumule les éléments d’entrée dans un conteneur de résultats mutable, en transformant éventuellement le résultat cumulé en une représentation finale après le traitement de tous les éléments d’entrée. |