ICollector Schnittstelle

Referenz

Definition

Namespace:: Java.Util.Streams

Assembly:: Mono.Android.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ein änderbarer Reduktionsvorgang, der Eingabeelemente in einen änderbaren Ergebniscontainer ansammelt und optional das angesammelte Ergebnis in eine endgültige Darstellung transformiert, nachdem alle Eingabeelemente verarbeitet wurden.

[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

Attribute: RegisterAttribute JavaTypeParametersAttribute

Implementiert: IJavaObject IJavaPeerable IDisposable

Hinweise

Beispiele für änderbare Reduzierungsvorgänge sind: Sammeln von Elementen in einer Collection; Verketten von Zeichenfolgen mithilfe einer StringBuilder; Berechnen von Zusammenfassungsinformationen zu Elementen wie Summe, Min, Max oder Mittelwert; Berechnen von "Pivot Table"-Zusammenfassungen wie "maximale Werttransaktion nach Verkäufer" usw. Die Klasse Collectors bietet Implementierungen vieler gängiger änderbarer Reduzierungen.

A Collector wird durch vier Funktionen angegeben, die zusammenarbeiten, um Einträge in einem änderbaren Ergebniscontainer zu sammeln, und optional eine endgültige Transformation für das Ergebnis ausführen. Sie sind: <ul><li>Erstellung eines neuen Ergebniscontainers (#supplier())</li li><>, der ein neues Datenelement in einen Ergebniscontainer ()</li li<>>integriert, der zwei Ergebniscontainer in eine (#combiner())</li li>><kombiniert, die eine optionale endgültige Transformation für den Container durchführt (#accumulator()#finisher())</li></ul>

Sammler verfügen auch über eine Reihe von Merkmalen, z Characteristics#CONCURRENT. B. mit Hinweisen, die von einer Reduktionsimplementierung verwendet werden können, um eine bessere Leistung zu erzielen.

Eine sequenzielle Implementierung einer Reduzierung mithilfe eines Sammelsammlers würde einen einzelnen Ergebniscontainer mithilfe der Lieferantenfunktion erstellen und die Akkumulatorfunktion einmal für jedes Eingabeelement aufrufen. Eine parallele Implementierung würde die Eingabe partitionieren, einen Ergebniscontainer für jede Partition erstellen, den Inhalt jeder Partition in ein Unterergebnis für diese Partition ansammeln und dann die Kombinationsfunktion verwenden, um die Teilergebnisse in einem kombinierten Ergebnis zusammenzuführen.

Um sicherzustellen, dass sequenzielle und parallele Ausführungen gleichwertige Ergebnisse erzeugen, müssen die Sammelfunktionen eine <Em-Identität></em> und eine Assoziivitätseinschränkung erfüllen.

Die Identitätseinschränkung besagt, dass für ein teilweise angesammeltes Ergebnis, das mit einem leeren Ergebniscontainer kombiniert wird, ein entsprechendes Ergebnis erzeugt werden muss. Das heißt, für ein teilweise angesammeltes Ergebnis a , das das Ergebnis einer Reihe von Akkumulator- und Kombinationsaufrufen ist, a muss gleichbedeutend combiner.apply(a, supplier.get())mit sein.

Die Assoziivitätseinschränkung besagt, dass das Aufteilen der Berechnung ein gleichwertiges Ergebnis erzeugen muss. Das heißt, für alle Eingabeelemente t1 und , die Ergebnisse r1 und r2t2in der folgenden Berechnung müssen gleichwertig sein:

{@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
            }

Bei Kollektoren, die nicht über das UNORDERED Merkmal verfügen, ergeben sich zwei gesammelte Ergebnisse a1 und a2 sind gleichwertig, wenn finisher.apply(a1).equals(finisher.apply(a2)). Bei ungeordneten Sammlern ist die Äquivalenz entspannt, um nicht gleichheitsbezogene Unterschiede in der Reihenfolge zu ermöglichen. (Ein ungeordneter Sammler, der Elemente ansammelte, List würde beispielsweise zwei Listen gleichwertig betrachten, wenn sie dieselben Elemente enthalten, wobei die Reihenfolge ignoriert wird.)

Bibliotheken, die eine Reduzierung basierend auf Collector, zStream#collect(Collector). B. , implementieren, müssen die folgenden Einschränkungen einhalten: <ul<>li>Das erste Argument, das an die Akkumulatorfunktion übergeben wurde, beide Argumente, die an die Kombinationsfunktion übergeben werden, und das an die Enderfunktion übergebene Argument muss das Ergebnis eines vorherigen Aufrufs des Ergebnisanbieters, Akkumulator- oder Kombinationsfunktion sein.</li Li><>Die Implementierung sollte nichts mit dem Ergebnis eines Der Ergebnislieferanten, Akkumulator- oder Kombinatorfunktionen tun, außer sie wieder an die Akkumulator-, Kombinator- oder Finisherfunktionen zu übergeben oder sie an den Aufrufer des Reduktionsvorgangs zurückzugeben.</li li><>Wenn ein Ergebnis an die Kombinations- oder Finisherfunktion übergeben wird und dasselbe Objekt nicht von dieser Funktion zurückgegeben wird, wird es nie wieder verwendet.</li li><>Sobald ein Ergebnis an die Kombinations- oder Finisherfunktion übergeben wird, wird es nie wieder an die Akkumulatorfunktion übergeben.</li><Li>Für nicht gleichzeitige Kollektoren müssen alle ergebnisse, die vom Ergebnislieferanten, Akkumulator oder Combiner-Funktionen zurückgegeben werden, fortlaufend threadgegrenzt sein. Dadurch kann die Sammlung parallel erfolgen, ohne Collector dass eine zusätzliche Synchronisierung implementiert werden muss. Die Implementierung der Reduzierung muss verwalten, dass die Eingabe ordnungsgemäß partitioniert ist, dass Partitionen isoliert verarbeitet werden, und die Kombination erfolgt erst nach Abschluss der Akkumulation.</li li><>Für gleichzeitige Kollektoren ist eine Implementierung frei (aber nicht erforderlich), gleichzeitig zu implementieren. Eine gleichzeitige Reduzierung ist eine, bei der die Akkumulatorfunktion gleichzeitig von mehreren Threads aufgerufen wird, wobei derselbe gleichzeitig modifizierbare Ergebniscontainer verwendet wird, anstatt das Ergebnis während der Akkumulation isoliert zu halten. Eine gleichzeitige Reduzierung sollte nur angewendet werden, wenn der Sammler über die Characteristics#UNORDERED Merkmale verfügt oder die Ursprungsdaten nicht angeordnet sind.</li></ul>

Zusätzlich zu den vordefinierten Implementierungen in Collectorskönnen die statischen Factorymethoden #of(Supplier, BiConsumer, BinaryOperator, Characteristics...) zum Erstellen von Sammlern verwendet werden. Sie können z. B. einen Sammelsammler erstellen, der Widgets in einem TreeSet mit:

{@code
                Collector<Widget, ?, TreeSet<Widget>> intoSet =
                    Collector.of(TreeSet::new, TreeSet::add,
                                 (left, right) -> { left.addAll(right); return left; });
            }

(Dieses Verhalten wird auch vom vordefinierten Sammler Collectors#toCollection(Supplier)implementiert).

Hinzugefügt in 1.8.

Java-Dokumentation für java.util.stream.Collector.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die vom Android Open Source-Projekt erstellt und freigegeben werden und gemäß den in der Creative Commons 2.5 Attribution License beschriebenen Begriffen verwendet werden.

Eigenschaften

Handle	Ruft den JNI-Wert des zugrunde liegenden Android-Objekts ab. (Geerbt von IJavaObject)
JniIdentityHashCode	Gibt den Wert `java.lang.System.identityHashCode()` für die umbrochene Instanz zurück. (Geerbt von IJavaPeerable)
JniManagedPeerState	Status des verwalteten Peers. (Geerbt von IJavaPeerable)
JniPeerMembers	Mitgliedszugriff und Aufrufunterstützung. (Geerbt von IJavaPeerable)
PeerReference	Gibt eine JniObjectReference der umbrochenen Java-Objektinstanz zurück. (Geerbt von IJavaPeerable)

Methoden

Accumulator()	Eine Funktion, die einen Wert in einen änderbaren Ergebniscontainer faltet.
Characteristics()	Gibt einen `Set` Wert zurück, der `Collector.Characteristics` die Merkmale dieses Collector angibt.
Combiner()	Eine Funktion, die zwei Teilergebnisse akzeptiert und zusammenführt.
Disposed()	Wird aufgerufen, wenn die Instanz verworfen wurde. (Geerbt von IJavaPeerable)
DisposeUnlessReferenced()	Wenn keine offenen Verweise auf diese Instanz vorhanden sind, wird nichts aufgerufen `Dispose()`. Andernfalls wird nichts ausgeführt. (Geerbt von IJavaPeerable)
Finalized()	Wird aufgerufen, wenn die Instanz abgeschlossen wurde. (Geerbt von IJavaPeerable)
Finisher()	Führen Sie die endgültige Transformation vom Zwischenakkumulationstyp `A` zum endgültigen Ergebnistyp `R`aus.
Of(ISupplier, IBiConsumer, IBinaryOperator, CollectorCharacteristics[])	Gibt eine neue `Collector` , die durch die angegebenen `supplier`, `accumulator`, , `combiner`, und `finisher` Funktionen beschrieben wird.
Of(ISupplier, IBiConsumer, IBinaryOperator, IFunction, CollectorCharacteristics[])	Gibt eine neue `Collector` , die durch die angegebenen `supplier`, `accumulator`, , `combiner`, und `finisher` Funktionen beschrieben wird.
SetJniIdentityHashCode(Int32)	Legen Sie den von `JniIdentityHashCode`. (Geerbt von IJavaPeerable)
SetJniManagedPeerState(JniManagedPeerStates)	Ein änderbarer Reduktionsvorgang, der Eingabeelemente in einen änderbaren Ergebniscontainer ansammelt und optional das angesammelte Ergebnis in eine endgültige Darstellung transformiert, nachdem alle Eingabeelemente verarbeitet wurden. (Geerbt von IJavaPeerable)
SetPeerReference(JniObjectReference)	Legen Sie den von `PeerReference`. (Geerbt von IJavaPeerable)
Supplier()	Eine Funktion, die einen neuen änderbaren Ergebniscontainer erstellt und zurückgibt.
UnregisterFromRuntime()	Heben Sie die Registrierung dieser Instanz auf, damit die Laufzeit sie nicht aus zukünftigen Java.Interop.JniRuntime+JniValueManager.PeekValue Aufrufen zurückgibt. (Geerbt von IJavaPeerable)

Erweiterungsmethoden

JavaCast<TResult>(IJavaObject)	Führt eine android-laufzeitgecheckte Typkonvertierung aus.
JavaCast<TResult>(IJavaObject)	Ein änderbarer Reduktionsvorgang, der Eingabeelemente in einen änderbaren Ergebniscontainer ansammelt und optional das angesammelte Ergebnis in eine endgültige Darstellung transformiert, nachdem alle Eingabeelemente verarbeitet wurden.
GetJniTypeName(IJavaPeerable)	Ein änderbarer Reduktionsvorgang, der Eingabeelemente in einen änderbaren Ergebniscontainer ansammelt und optional das angesammelte Ergebnis in eine endgültige Darstellung transformiert, nachdem alle Eingabeelemente verarbeitet wurden.

Gilt für:

Freigeben über