Arrays.stream() O(n) 或 O(n log n) 的时间复杂度是多少？

Question

Stream API documentation says:

certain stream sources (such as List or arrays ) are intrinsically ordered , whereas others (such as HashSet ) are not.

What would be the time complexity of Arrays.stream() method?

O(n log n) , as it returns sorted array, or O(n) , as we expect from stream() s methods ?

Answer 1

O(n) or O(nlogn) ?

Neither of these.

Firstly , it seems like you're confusing a stream which elements are sorted with an ordered stream, ie a stream which has a particular encounter order of elements.

Whether a stream is ordered or not depends on the stream source and intermediate operations in it.

A stream created over an array, or ordered collection like a List , or a Queue is ordered respectively to order elements in it, but it does not imply that such stream is sorted.

We can make a stream unordered by applying unordered() operation on in it. This operation alone will not change the stream data, but it will have an impact on the execution of stateful intermediate operations like takeWhile() that require buffering, and terminal operation like reduce() , collect() that give a guarantee to respect the initial encounter order. As a result, a parallel unordered stream might have better performance because of loosening this constraint.

Here is a quote from the API documentation :

Ordering

Streams may or may not have a defined encounter order . Whether or not a stream has an encounter order depends on the source and the intermediate operations . Certain stream sources (such as List or arrays ) are intrinsically ordered , whereas others (such as HashSet ) are not. Some intermediate operations, such as sorted() , may impose an encounter order on an otherwise unordered stream, and others may render an ordered stream unordered, such as BaseStream.unordered() . Further, some terminal operations may ignore encounter order, such as forEach() .

If a stream is ordered, most operations are constrained to operate on the elements in their encounter order; if the source of a stream is a List containing [1, 2, 3] , then the result of executing map(x -> x*2) must be [2, 4, 6] . However, if the source has no defined encounter order, then any permutation of the values [2, 4, 6] would be a valid result.

For sequential streams, the presence or absence of an encounter order does not affect performance, only determinism. If a stream is ordered, repeated execution of identical stream pipelines on an identical source will produce an identical result; if it is not ordered, repeated execution might produce different results.

For parallel streams, relaxing the ordering constraint can sometimes enable more efficient execution. Certain aggregate operations, such as filtering duplicates ( distinct() ) or grouped reductions ( Collectors.groupingBy() ) can be implemented more efficiently if ordering of elements is not relevant. Similarly, operations that are intrinsically tied to encounter order, such as limit() , may require buffering to ensure proper ordering, undermining the benefit of parallelism. In cases where the stream has an encounter order, but the user does not particularly care about that encounter order, explicitly de-ordering the stream with unordered() may improve parallel performance for some stateful or terminal operations. However, most stream pipelines, such as the "sum of weight of blocks" example above, still parallelize efficiently even under ordering constraints.

Secondly , because you're assuming that creating a stream over an array will cost at list O(n) you might have a misconception regarding the nature of streams.

In essence, stream is a mean of iteration , it is not a container of data like Collection.

Creation of a stream doesn't require dumping all the data from the source into memory, we're only creating an internal iterator over the source of data, and this action has a time complexity of O(1) .

Streams are lazy and every action in the stream pipeline occur only when it's needed, and elements from the source are processed one by one.

For instance, let's assume we have an integer array containing 1,000,000 elements, and we want to get the first 10 elements from it as hexadecimal strings:

List<String> result = Arrays.stream(sourceArray)
    .mapToObj(Integer::toHexString)
    .limit(10)
    .toList();

On execution, only the first 10 elements would be retrieved from the source array, and then the stream would immediately terminate, producing the result.

The overall time complexity of such a stream would be O(1) because we care only about a fixed number of elements at the very beginning, and don't need all the data that the source contains.