Obtenha o último elemento de Stream / List em uma linha

Como posso obter o último elemento de um fluxo ou lista no código a seguir?

Onde data.careasestá um List<CArea>:

CArea first = data.careas.stream()
                  .filter(c -> c.bbox.orientationHorizontal).findFirst().get();

CArea last = data.careas.stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .collect(Collectors.toList()).; //how to?

Como você pode ver, pegar o primeiro elemento, com uma certa filter, não é difícil.

No entanto, obter o último elemento em uma linha é uma verdadeira dor:

• Parece que não posso obtê-lo diretamente de a Stream. (Só faria sentido para fluxos finitos)
• Também parece que você não pode obter coisas como first()e last()da Listinterface, o que é realmente uma dor.

Não vejo nenhum argumento para não fornecer um método first()e last()na Listinterface, pois os elementos lá são ordenados e, além disso, o tamanho é conhecido.

Mas de acordo com a resposta original: Como obter o último elemento de um finito Stream?

Pessoalmente, isso é o mais próximo que consegui:

int lastIndex = data.careas.stream()
        .filter(c -> c.bbox.orientationHorizontal)
        .mapToInt(c -> data.careas.indexOf(c)).max().getAsInt();
CArea last = data.careas.get(lastIndex);

No entanto, envolve o uso de um indexOfem todos os elementos, o que geralmente você não deseja, pois pode prejudicar o desempenho.

É possível obter o último elemento com o método Stream :: reduce . A lista a seguir contém um exemplo mínimo para o caso geral:

Stream<T> stream = ...; // sequential or parallel stream
Optional<T> last = stream.reduce((first, second) -> second);

Essas implementações funcionam para todos os fluxos ordenados (incluindo fluxos criados a partir de listas ). Para fluxos não ordenados , por razões óbvias não é especificado qual elemento será retornado.

A implementação funciona para fluxos sequenciais e paralelos . Isso pode ser surpreendente à primeira vista e, infelizmente, a documentação não afirma isso explicitamente. No entanto, é um recurso importante dos streams, e tento esclarecê-lo:

• O Javadoc para o método Stream :: reduce afirma que " não está restrito a executar sequencialmente " .
• O Javadoc também requer que a "função acumuladora deve ser uma função associativa , não interferente e sem estado para combinar dois valores" , o que é obviamente o caso da expressão lambda (first, second) -> second.
• O Javadoc para operações de redução declara: "As classes de streams têm várias formas de operações de redução geral, chamadas reduce () e collect () [..]" e "uma operação de redução construída corretamente é inerentemente paralelizável , desde que as funções ) usados ​​para processar os elementos são associativos e sem estado . "

A documentação para os coletores intimamente relacionados é ainda mais explícita: "Para garantir que as execuções sequenciais e paralelas produzam resultados equivalentes , as funções do coletor devem satisfazer as restrições de identidade e associatividade ."

De volta à pergunta original: o código a seguir armazena uma referência ao último elemento na variável laste lança uma exceção se o fluxo estiver vazio. A complexidade é linear no comprimento do fluxo.

CArea last = data.careas
                 .stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .reduce((first, second) -> second).get();

Se você tem uma coleção (ou mais um Iterable geral), pode usar o Google Guava's

Iterables.getLast(myIterable)

como oneliner útil.

Um forro (sem necessidade de fluxo;):

Object lastElement = list.get(list.size()-1);

Guava tem método dedicado para este caso:

Stream<T> stream = ...;
Optional<T> lastItem = Streams.findLast(stream);

É equivalente a, stream.reduce((a, b) -> b)mas os criadores afirmam que tem um desempenho muito melhor.

Da documentação :

O tempo de execução desse método será entre O (log n) e O (n), com melhor desempenho em fluxos divisíveis de forma eficiente.

Vale a pena mencionar que se o stream estiver desordenado este método se comporta como findAny().

Se você precisar obter o último número N de elementos. O fechamento pode ser usado. O código abaixo mantém uma fila externa de tamanho fixo até que o fluxo chegue ao fim.

    final Queue<Integer> queue = new LinkedList<>();
    final int N=5;
    list.stream().peek((z) -> {
        queue.offer(z);
        if (queue.size() > N)
            queue.poll();
    }).count();

Outra opção poderia ser usar a operação de redução usando a identidade como uma fila.

    final int lastN=3;
    Queue<Integer> reduce1 = list.stream()
    .reduce( 
        (Queue<Integer>)new LinkedList<Integer>(), 
        (m, n) -> {
            m.offer(n);
            if (m.size() > lastN)
               m.poll();
            return m;
    }, (m, n) -> m);

    System.out.println("reduce1 = " + reduce1);

Você também pode usar a função skip () conforme abaixo ...

long count = data.careas.count();
CArea last = data.careas.stream().skip(count - 1).findFirst().get();

é super simples de usar.