ICollector Interface
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Uma operação de redução mutável que acumula elementos de entrada em um contêiner de resultado mutável, opcionalmente transformando o resultado acumulado em uma representação final depois que todos os elementos de entrada tiverem sido processados.
[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- Atributos
- Implementações
Comentários
Uma operação de redução mutável que acumula elementos de entrada em um contêiner de resultado mutável, opcionalmente transformando o resultado acumulado em uma representação final depois que todos os elementos de entrada tiverem sido processados. As operações de redução podem ser realizadas sequencialmente ou em paralelo.
Exemplos de operações de redução mutáveis incluem: acumular elementos em um Collection, concatenar cadeias de caracteres usando um StringBuilder, calcular informações resumidas sobre elementos como soma, min, max ou média, calcular resumos de "tabela dinâmica", como "transação de valor máximo por vendedor", etc. A classe Collectors fornece implementações de muitas reduções mutáveis comuns.
A Collector é especificado por quatro funções que trabalham juntas para acumular entradas em um contêiner de resultados mutável e, opcionalmente, executar uma transformação final no resultado. São eles: <ul><li>criação de um novo contêiner de resultado (#supplier())</li><li>incorporando um novo elemento de dados em um contêiner de resultado (#accumulator())</li<>li>combinando dois contêineres de resultado em um (#combiner())</li><li>executando uma transformação final opcional no contêiner (#finisher())</li></ul>
Os coletores também possuem um conjunto de características, como Characteristics#CONCURRENT, que fornecem dicas que podem ser usadas por uma implementação de redução para proporcionar melhor desempenho.
Uma implementação sequencial de uma redução usando um coletor criaria um único contêiner de resultado usando a função de fornecedor e invocaria a função de acumulador uma vez para cada elemento de entrada. Uma implementação paralela particionaria a entrada, criaria um contêiner de resultados para cada partição, acumularia o conteúdo de cada partição em um subresultado para essa partição e, em seguida, usaria a função combinador para mesclar os subresultados em um resultado combinado.
Para garantir que execuções sequenciais e paralelas produzam resultados equivalentes, as funções do coletor devem satisfazer uma <identidade< em>/em> e uma restrição de associatividade.
A restrição de identidade diz que, para qualquer resultado parcialmente acumulado, combiná-lo com um recipiente de resultado vazio deve produzir um resultado equivalente. Ou seja, para um resultado a parcialmente acumulado que é o resultado de qualquer série de invocações de acumulador e combinador, a deve ser equivalente a combiner.apply(a, supplier.get()).
A restrição de associatividade diz que dividir a computação deve produzir um resultado equivalente. Ou seja, para quaisquer elementos t1 de entrada e t2, os resultados r1 e r2 no cálculo abaixo devem ser equivalentes:
{@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
}
Para coletores que não possuem a UNORDERED característica, dois resultados a1 acumulados e a2 equivalem se finisher.apply(a1).equals(finisher.apply(a2)). Para colecionadores não ordenados, a equivalência é relaxada para permitir a não igualdade relacionada às diferenças de ordem. (Por exemplo, um coletor não ordenado que acumulou elementos para um List consideraria duas listas equivalentes se elas contivessem os mesmos elementos, ignorando a ordem.)
As bibliotecas que implementam a redução com base no Collector, como Stream#collect(Collector), devem aderir às seguintes restrições: <ul<>li>O primeiro argumento passado para a função acumulador, ambos os argumentos passados para a função combinador e o argumento passado para a função finisher devem ser o resultado de uma invocação anterior das funções fornecedor, acumulador ou combinador de resultados.</li><li>A implementação não deve fazer nada com o resultado de qualquer das funções de fornecedor, acumulador ou combinador de resultados a não ser passá-las novamente para as funções de acumulador, combinador ou finalizador, ou devolvê-las ao chamador da operação de redução.</li><li Se>um resultado for passado para a função combinador ou finalizador e o mesmo objeto não for retornado dessa função, ele nunca será usado novamente.</li><li Uma>vez que um resultado é passado para a função combinador ou finalizador, ele nunca mais é passado para a função acumulador.</li><li>Para coletores não simultâneos, qualquer resultado retornado das funções de fornecedor, acumulador ou combinador de resultados deve ser confinado em série por rosca. Isso permite que a coleta ocorra em paralelo sem a Collector necessidade de implementar qualquer sincronização adicional. A implementação de redução deve gerenciar que a entrada seja particionada corretamente, que as partições sejam processadas isoladamente e a combinação aconteça somente após a conclusão do acúmulo.</li><li>Para coletores simultâneos, uma implementação é livre para (mas não é necessária para) implementar a redução simultaneamente. Uma redução simultânea é aquela em que a função do acumulador é chamada simultaneamente de vários threads, usando o mesmo contêiner de resultado simultaneamente modificável, em vez de manter o resultado isolado durante a acumulação. Uma redução simultânea só deve ser aplicada se o coletor tiver as Characteristics#UNORDERED características ou se os dados de origem não forem ordenados.</li></ul>
Além das implementações predefinidas no Collectors, os métodos #of(Supplier, BiConsumer, BinaryOperator, Characteristics...) de fábrica estáticos podem ser usados para construir coletores. Por exemplo, você pode criar um coletor que acumule widgets em um TreeSet com:
{@code
Collector<Widget, ?, TreeSet<Widget>> intoSet =
Collector.of(TreeSet::new, TreeSet::add,
(left, right) -> { left.addAll(right); return left; });
}
(Esse comportamento também é implementado pelo coletor Collectors#toCollection(Supplier)predefinido ).
Adicionado em 1.8.
Documentação Java para java.util.stream.Collector.
Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usado de acordo com os termos descritos na Creative Commons 2.5 Attribution License.
Propriedades
| Handle |
Obtém o valor JNI do objeto Android subjacente. (Herdado de IJavaObject) |
| JniIdentityHashCode |
Retorna o valor de |
| JniManagedPeerState |
Estado do par gerenciado. (Herdado de IJavaPeerable) |
| JniPeerMembers |
Acesso de membros e suporte à invocação. (Herdado de IJavaPeerable) |
| PeerReference |
Retorna uma JniObjectReference das instâncias do objeto Java encapsulado. (Herdado de IJavaPeerable) |
Métodos
| Accumulator() |
Uma função que dobra um valor em um contêiner de resultado mutável. |
| Characteristics() |
Retorna um |
| Combiner() |
Uma função que aceita dois resultados parciais e os mescla. |
| Disposed() |
Chamado quando a instância tiver sido descartada. (Herdado de IJavaPeerable) |
| DisposeUnlessReferenced() |
Se não houver referências pendentes a este caso, então chame |
| Finalized() |
Chamado quando a instância tiver sido finalizada. (Herdado de IJavaPeerable) |
| Finisher() |
Realizar a transformação final do tipo |
| Of(ISupplier, IBiConsumer, IBinaryOperator, CollectorCharacteristics[]) |
Retorna um novo |
| Of(ISupplier, IBiConsumer, IBinaryOperator, IFunction, CollectorCharacteristics[]) |
Retorna um novo |
| SetJniIdentityHashCode(Int32) |
Defina o valor retornado por |
| SetJniManagedPeerState(JniManagedPeerStates) |
Uma operação de redução mutável que acumula elementos de entrada em um contêiner de resultado mutável, opcionalmente transformando o resultado acumulado em uma representação final depois que todos os elementos de entrada tiverem sido processados. (Herdado de IJavaPeerable) |
| SetPeerReference(JniObjectReference) |
Defina o valor retornado por |
| Supplier() |
Uma função que cria e retorna um novo contêiner de resultados mutável. |
| UnregisterFromRuntime() |
Cancele o registro dessa instância para que o tempo de execução não a retorne de chamadas futuras Java.Interop.JniRuntime+JniValueManager.PeekValue . (Herdado de IJavaPeerable) |
Métodos de Extensão
| JavaCast<TResult>(IJavaObject) |
Executa uma conversão de tipo verificada em tempo de execução do Android. |
| JavaCast<TResult>(IJavaObject) |
Uma operação de redução mutável que acumula elementos de entrada em um contêiner de resultado mutável, opcionalmente transformando o resultado acumulado em uma representação final depois que todos os elementos de entrada tiverem sido processados. |
| GetJniTypeName(IJavaPeerable) |
Uma operação de redução mutável que acumula elementos de entrada em um contêiner de resultado mutável, opcionalmente transformando o resultado acumulado em uma representação final depois que todos os elementos de entrada tiverem sido processados. |