ICollector Interfaccia

Riferimento

Definizione

Spazio dei nomi:: Java.Util.Streams

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Operazione di riduzione modificabile che accumula gli elementi di input in un contenitore di risultati modificabile, trasformando facoltativamente il risultato accumulato in una rappresentazione finale dopo l'elaborazione di tutti gli elementi di input.

[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

Attributi: RegisterAttribute JavaTypeParametersAttribute

Implementazioni: IJavaObject IJavaPeerable IDisposable

Commenti

Esempi di operazioni di riduzione modificabili includono: accumulare elementi in una ; concatenando stringhe usando un CollectionStringBuilder; calcolo delle informazioni di riepilogo sugli elementi, ad esempio somma, min, max o media; calcolo dei riepiloghi "tabella pivot", ad esempio "transazione massima valutata dal venditore", ecc. La classe Collectors fornisce implementazioni di molte riduzioni mutable comuni.

Un Collector oggetto viene specificato da quattro funzioni che interagiscono per accumulare voci in un contenitore di risultati modificabile e, facoltativamente, eseguire una trasformazione finale sul risultato. Sono: <ul><li>creazione di un nuovo contenitore di risultati ()/li><>che incorpora un nuovo elemento dati in un contenitore di risultati (<#accumulator())/li combinando due contenitori di risultati in uno#combiner() ()><<<>/><>li che esegue una trasformazione finale facoltativa nel contenitore#finisher() (#supplier())</li></ul>

Gli agenti di raccolta hanno anche un set di caratteristiche, ad esempio Characteristics#CONCURRENT, che forniscono hint che possono essere usati da un'implementazione di riduzione per offrire prestazioni migliori.

Un'implementazione sequenziale di una riduzione usando un agente di raccolta creerebbe un singolo contenitore di risultati usando la funzione fornitore e richiama la funzione accumulatore una volta per ogni elemento di input. Un'implementazione parallela partiziona l'input, crea un contenitore di risultati per ogni partizione, accumula il contenuto di ogni partizione in un sottoresult per tale partizione e quindi usa la funzione combinatore per unire le sottoresulte in un risultato combinato.

Per garantire che le esecuzioni sequenziali e parallele producano risultati equivalenti, le funzioni dell'agente di raccolta devono soddisfare un'identità <<em/em>> e vincoli di associatività.

Il vincolo identity indica che per qualsiasi risultato parzialmente accumulato, combinarlo con un contenitore di risultati vuoto deve produrre un risultato equivalente. Vale a dire, per un risultato a parzialmente accumulato che è il risultato di qualsiasi serie di chiamate di accumulatori e combinatore, a deve essere equivalente a combiner.apply(a, supplier.get()).

Il vincolo associativo indica che la suddivisione del calcolo deve produrre un risultato equivalente. Vale a dire, per tutti gli elementi t1 di input e , i risultati r1 e t2r2 nel calcolo seguente devono essere equivalenti:

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

Per gli agenti di raccolta che non hanno la UNORDERED caratteristica, due risultati a1 accumulati e a2 sono equivalenti se finisher.apply(a1).equals(finisher.apply(a2)). Per gli agenti di raccolta non ordinati, l'equivalenza è rilassata per consentire l'uguaglianza correlata alle differenze in ordine. Ad esempio, un agente di raccolta non ordinato che accumulava elementi in un List valore considererebbe due elenchi equivalenti se contengono gli stessi elementi, ignorando l'ordine.

Le librerie che implementano la riduzione in base Collectora , ad esempio Stream#collect(Collector), devono rispettare i vincoli seguenti: <ul><li>Il primo argomento passato alla funzione accumulatore, entrambi gli argomenti passati alla funzione combinatore e l'argomento passato alla funzione di completamento deve essere il risultato di una chiamata precedente del fornitore di risultati, dell'accumulatore o delle funzioni combinate.</li><>L'implementazione non deve fare nulla con il risultato di uno dei fornitori di risultati, dell'accumulatore o delle funzioni combinatore diverso da passare di nuovo alle funzioni di accumulatore, combinatore o finetore o restituirle al chiamante dell'operazione di riduzione.</li><>Se un risultato viene passato alla funzione combiner o finisher e lo stesso oggetto non viene restituito da tale funzione, non viene mai usato di nuovo.</li li><>Una volta che un risultato viene passato alla funzione combinatrice o fine, non viene mai passata alla funzione accumulatore.</li><li>Per gli agenti di raccolta non simultanei, tutti i risultati restituiti dal fornitore del risultato, dall'accumulatore o dalle funzioni combinatori devono essere vincolati in serie. Ciò consente alla raccolta di verificarsi in parallelo senza la Collector necessità di implementare alcuna sincronizzazione aggiuntiva. L'implementazione della riduzione deve gestire che l'input sia partizionato correttamente, che le partizioni vengano elaborate in isolamento e che la combinazione si verifichi solo dopo il completamento dell'accumulo.</li><Li>Per gli agenti di raccolta simultanei, un'implementazione è gratuita (ma non necessaria) implementare la riduzione simultaneamente. Una riduzione simultanea è una posizione in cui la funzione accumulatore viene chiamata simultaneamente da più thread, usando lo stesso contenitore di risultati modificabile simultaneamente, anziché mantenere isolato il risultato durante l'accumulo. Una riduzione simultanea deve essere applicata solo se l'agente di raccolta ha le Characteristics#UNORDERED caratteristiche o se i dati di origine non sono ordinati.</li></ul>

Oltre alle implementazioni predefinite in Collectors, è possibile usare i metodi #of(Supplier, BiConsumer, BinaryOperator, Characteristics...) di factory statici per costruire gli agenti di raccolta. Ad esempio, è possibile creare un agente di raccolta che accumula widget in un TreeSet con:

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

Questo comportamento viene implementato anche dall'agente di raccolta Collectors#toCollection(Supplier)predefinito .

Aggiunta nella versione 1.8.

Documentazione Java per java.util.stream.Collector.

Le parti di questa pagina sono modifiche in base al lavoro creato e condiviso dal Android Open Source e usato in base ai termini descritti nella .

Proprietà

Handle	Ottiene il valore JNI dell'oggetto Android sottostante. (Ereditato da IJavaObject)
JniIdentityHashCode	Restituisce il valore di per `java.lang.System.identityHashCode()` l'istanza di wrapped. (Ereditato da IJavaPeerable)
JniManagedPeerState	Stato del peer gestito. (Ereditato da IJavaPeerable)
JniPeerMembers	Supporto per l'accesso ai membri e la chiamata. (Ereditato da IJavaPeerable)
PeerReference	Restituisce un'istanza JniObjectReference dell'oggetto Java con wrapping. (Ereditato da IJavaPeerable)

Metodi

Accumulator()	Funzione che piega un valore in un contenitore risultato modificabile.
Characteristics()	Restituisce un `Set` oggetto di `Collector.Characteristics` che indica le caratteristiche di questo agente di raccolta.
Combiner()	Funzione che accetta due risultati parziali e li unisce.
Disposed()	Chiamato quando l'istanza è stata eliminata. (Ereditato da IJavaPeerable)
DisposeUnlessReferenced()	Se non sono presenti riferimenti in sospeso a questa istanza, chiama `Dispose()`; in caso contrario, non fa nulla. (Ereditato da IJavaPeerable)
Finalized()	Chiamato quando l'istanza è stata finalizzata. (Ereditato da IJavaPeerable)
Finisher()	Eseguire la trasformazione finale dal tipo `A` di accumulo intermedio al tipo di `R`risultato finale .
Of(ISupplier, IBiConsumer, IBinaryOperator, CollectorCharacteristics[])	Restituisce un nuovo `Collector` oggetto descritto dalle funzioni , `accumulator`, `combiner`e `finisher` specificati`supplier`.
Of(ISupplier, IBiConsumer, IBinaryOperator, IFunction, CollectorCharacteristics[])	Restituisce un nuovo `Collector` oggetto descritto dalle funzioni , `accumulator`, `combiner`e `finisher` specificati`supplier`.
SetJniIdentityHashCode(Int32)	Impostare il valore restituito da `JniIdentityHashCode`. (Ereditato da IJavaPeerable)
SetJniManagedPeerState(JniManagedPeerStates)	Operazione di riduzione modificabile che accumula gli elementi di input in un contenitore di risultati modificabile, trasformando facoltativamente il risultato accumulato in una rappresentazione finale dopo l'elaborazione di tutti gli elementi di input. (Ereditato da IJavaPeerable)
SetPeerReference(JniObjectReference)	Impostare il valore restituito da `PeerReference`. (Ereditato da IJavaPeerable)
Supplier()	Funzione che crea e restituisce un nuovo contenitore di risultati modificabile.
UnregisterFromRuntime()	Annullare la registrazione di questa istanza in modo che il runtime non lo restituirà dalle chiamate future Java.Interop.JniRuntime+JniValueManager.PeekValue . (Ereditato da IJavaPeerable)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione dei tipi controllati dal runtime Android.
JavaCast<TResult>(IJavaObject)	Operazione di riduzione modificabile che accumula gli elementi di input in un contenitore di risultati modificabile, trasformando facoltativamente il risultato accumulato in una rappresentazione finale dopo l'elaborazione di tutti gli elementi di input.
GetJniTypeName(IJavaPeerable)	Operazione di riduzione modificabile che accumula gli elementi di input in un contenitore di risultati modificabile, trasformando facoltativamente il risultato accumulato in una rappresentazione finale dopo l'elaborazione di tutti gli elementi di input.

Si applica a

Condividi tramite