Is it possible to create Stream implementation that counts their elements in a single operation

Question

Q: Is it possible to create Stream implementation that counts their elements in a single operation rather than counting each and every element in the stream?

I came to this though when i tried to compare two methods on a list :

• size()

• count()

Stream::count terminal operation counts the number of elements in a Stream. The complexity of the operation is often O(N), meaning that the number of sub-operations is proportional to the number of elements in the Stream.

List::size method has a complexity of O(1), which means that regardless of the number of elements in the List, the size() method will return in constant time.

   List<Integer> list = IntStream.range(0, 100).boxed().collect(toList());
    System.out.println(list.size());
    System.out.println(list.stream().count());

---

size() took a relative less time than count(),so is there any possible way to create Stream implementation that counts their elements in a single operation and make a complexity of O(1) ??

---

Edit Article to answer Yes:

It is possible to create Stream implementation that counts their elements in a single operation O(1) rather than counting each and every element in the stream. This can improve performance significantly, especially for streams with many elements.

Answer 1

This is already happening in Java 9 and newer (considering the OpenJDK implementation which is also the base for Oracle’s JDK).

If you want a similar operation, you can use, e.g.

public static long count(BaseStream<?,?> s) {
    Spliterator<?> sp = s.spliterator();
    long c = sp.getExactSizeIfKnown();
    if(c >= 0) return c;
    final class Counter implements Consumer<Object>,
        IntConsumer, LongConsumer, DoubleConsumer { // avoid boxing where possible
        long count;
        public void accept(Object t) { count++; }
        public void accept(int value) { count++; }
        public void accept(long value) { count++; }
        public void accept(double value) { count++; }
    }
    Counter c = new Counter();
    sp.forEachRemaining(c);
    return c.count;
}

You can check that it won’t process all elements with

System.out.println(count(IntStream.range(0, 100).peek(System.out::println)));
System.out.println(count(Stream.of("a", "b", "c").peek(System.out::println)));

whereas inserting a filter operation like

System.out.println(count(Stream.of("a", "b", "c")
    .peek(System.out::println).filter(x -> true)));

will make the count unpredictable and require a traversal.

As said above, in JDK 9 or newer, you can simple use

System.out.println(Stream.of("a", "b", "c").peek(System.out::println).count());

and

System.out.println(Stream.of("a", "b", "c")
    .peek(System.out::println).filter(x -> true).count());

to see that the traversal does not happen when the count is predictable.