Получить последний элемент Stream / List в однострочном формате

Как я могу получить последний элемент потока или списка в следующем коде?

Где data.careasнаходится 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?

Как видите, получить первый элемент filterне сложно.

Однако получение последнего элемента в однострочнике - настоящая боль:

• Кажется, я не могу получить его напрямую от Stream. (Это имело бы смысл только для конечных потоков)
• Также кажется, что вы не можете получить что-то вроде first()и last()из Listинтерфейса, что действительно неприятно.

Я не вижу никаких аргументов для не обеспечивая first()и last()метод в Listинтерфейсе, как элементы в наличии, упорядочены, и , кроме того размер известен.

Но согласно первоначальному ответу: как получить последний элемент конечного Stream?

Лично мне это ближе всего:

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

Однако это подразумевает использование для indexOfкаждого элемента, что, скорее всего, вам обычно не нужно, поскольку это может снизить производительность.

Получить последний элемент можно методом Stream :: reduce . Следующий листинг содержит минимальный пример для общего случая:

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

Эта реализация работает для всех упорядоченных потоков (включая потоки, созданные из списков ). Для неупорядоченных потоков по очевидным причинам не указано, какой элемент будет возвращен.

Реализация работает как для последовательных, так и для параллельных потоков . На первый взгляд это может показаться неожиданным, и, к сожалению, в документации об этом прямо не говорится. Однако это важная особенность потоков, и я пытаюсь ее прояснить:

• В Javadoc для метода Stream :: reduce говорится, что он « не ограничен для последовательного выполнения » .
• Javadoc также требует, чтобы «функция аккумулятора должна представлять собой ассоциативный , без мешающего , без сохранения функции для объединения двух значений» , которое, очевидно , имеет место для лямбда - выражения(first, second) -> second .
• В Javadoc для операций сокращения говорится: «Классы потоков имеют несколько форм общих операций сокращения, называемых reduce () и collect () [..]», и «правильно построенная операция сокращения по своей сути является распараллеливаемой , если функция (s ), используемые для обработки элементов, являются ассоциативными и не имеют состояния ".

Документация для тесно связанных сборщиков еще более ясна: «Чтобы гарантировать, что последовательное и параллельное выполнение дает эквивалентные результаты , функции сборщика должны удовлетворять ограничениям идентичности и ассоциативности ».

Вернемся к исходному вопросу: следующий код сохраняет ссылку на последний элемент переменной lastи выдает исключение, если поток пуст. Сложность линейна по длине потока.

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

Если у вас есть коллекция (или в более общем плане Iterable), вы можете использовать Google Guava

Iterables.getLast(myIterable)

как удобный oneliner.

Один лайнер (поток не нужен;):

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

У Guava есть специальный метод для этого случая:

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

Это эквивалентно stream.reduce((a, b) -> b) но создатели утверждают, что у него намного лучшая производительность.

Из документации :

Время выполнения этого метода будет между O (log n) и O (n), что позволит лучше работать с эффективно разделяемыми потоками.

Стоит отметить, что если поток неупорядочен, этот метод ведет себя как findAny().

Если вам нужно получить последние N элементов. Можно использовать закрытие. Приведенный ниже код поддерживает внешнюю очередь фиксированного размера до тех пор, пока поток не достигнет конца.

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

Другой вариант - использовать операцию сокращения с использованием идентификатора в качестве очереди.

    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);

Вы также можете использовать функцию skip (), как показано ниже ...

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

это очень просто в использовании.