Отримайте останній елемент потоку / списку в одній вкладиші

Як я можу отримати останній елемент потоку чи списку в наступному коді?

Де 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інтерфейсу, який насправді біль.

Я не бачу жодного аргументу щодо не надання a 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 :: Reduct . Наступний перелік містить мінімальний приклад для загального випадку:

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

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

Реалізація працює як для послідовних, так і для паралельних потоків . Це може здивувати на перший погляд, і, на жаль, у документації це не зазначено прямо. Однак це важлива особливість потоків, і я намагаюся уточнити це:

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

Документація для тісно пов'язаних колекціонерів ще більш чітка: "Для того, щоб послідовне і паралельне виконання дало еквівалентні результати , функції колектора повинні задовольняти обмеження ідентичності та асоціативності ".

Назад до початкового запитання: Наступний код зберігає посилання на останній елемент змінної lastі видає виняток, якщо потік порожній. Складність лінійна за довжиною потоку.

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

Якщо у вас є колекція (або більш загальнодоступна), ви можете скористатися послугами Google Guava

Iterables.getLast(myIterable)

як зручний oneliner.

Один вкладиш (немає потреби в потоці;):

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

Гуава виділив метод для цієї справи:

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

це дуже просто у використанні.