It is possible to get the last element with the method Stream::reduce. The following listing contains a minimal example for the general case:

可以使用Stream::reduce方法获取最后一个元素。以下清单包含一般情况的最小示例：

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

This implementations works for all ordered streams(including streams created from Lists). For unorderedstreams it is for obvious reasons unspecified which element will be returned.

此实现适用于所有有序流（包括从Lists创建的流）。对于无序流，由于显而易见的原因，未指定将返回哪个元素。

The implementation works for both sequentialand parallel streams. That might be surprising at first glance, and unfortunately the documentation doesn't state it explicitly. However, it is an important feature of streams, and I try to clarify it:

该实现适用于顺序流和并行流。乍一看这可能令人惊讶，不幸的是文档没有明确说明。然而，它是流的一个重要特性，我试图澄清它：

• The Javadoc for the method Stream::reducestates, that it "is notconstrained to execute sequentially".
• The Javadoc also requires that the "accumulator function must be an associative, non-interfering, statelessfunction for combining two values", which is obviously the case for the lambda expression (first, second) -> second.
• The Javadoc for reduction operationsstates: "The streams classes have multiple forms of general reduction operations, called reduce()and collect()[..]"and "a properly constructed reduce operation is inherently parallelizable, so long as the function(s) used to process the elements are associativeand stateless."

• Stream::reduce方法的 Javadoc指出，它“不受限于顺序执行”。
• Javadoc 还要求“累加器函数必须是用于组合两个值的关联的、无干扰的、无状态的函数”，这显然是 lambda 表达式的情况(first, second) -> second。
• 简化操作的 Javadoc指出：“流类具有多种形式的通用归约操作，称为reduce()和collect()[..]”和“正确构造的归约操作本质上是可并行化的，只要函数) 用于处理的元素是关联的和无状态的。”

The documentation for the closely related Collectorsis even more explicit: "To ensure that sequentialand parallel executionsproduce equivalent results, the collector functions must satisfy an identity and an associativityconstraints."

密切相关的收集器的文档更加明确：“为了确保顺序和并行执行产生相同的结果，收集器函数必须满足同一性和关联性约束。”

Back to the original question: The following code stores a reference to the last element in the variable lastand throws an exception if the stream is empty. The complexity is linear in the length of the stream.

回到最初的问题：以下代码存储对变量中最后一个元素的引用，last如果流为空则抛出异常。复杂度与流的长度呈线性关系。

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

If you have a Collection (or more general an Iterable) you can use Google Guava's

如果你有一个集合（或更一般的迭代），你可以使用谷歌番石榴

Iterables.getLast(myIterable)

as handy oneliner.

作为方便的oneliner。

One liner (no need for stream;):

一个班轮（不需要流；）：

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

You can also use skip() function as below...

您还可以使用 skip() 函数，如下所示...

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

it's super simple to use.

使用起来超级简单。

Guava has dedicated method for this case:

Guava 有专门的方法来处理这种情况：

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

It's equivalent to stream.reduce((a, b) -> b)but creators claim it has much better performance.

它相当于stream.reduce((a, b) -> b)但创作者声称它具有更好的性能。

From documentation:

从文档：

This method's runtime will be between O(log n) and O(n), performing better on efficiently splittable streams.

此方法的运行时将介于 O(log n) 和 O(n) 之间，在高效可拆分流上表现更好。

It's worth to mention that if stream is unordered this method behaves like findAny().

值得一提的是，如果流是无序的，则此方法的行为类似于findAny().

If you need to get the last N number of elements. Closure can be used. The below code maintains an external queue of fixed size until, the stream reaches the end.

如果需要获取最后 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();

Another option could be to use reduce operation using identity as a Queue.

另一种选择可能是使用使用身份作为队列的减少操作。

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