Arrays.parallel vs Arrays.asStream
aleksey.shipilev at oracle.com
Mon Sep 3 01:22:29 PDT 2012
Never expected the academic insight into this :)
I think Arrays.parallel() is having the same conceptual weight as
Arrays.asStream(), hence the obvious rename would be Arrays.parallel()
I also tend to think this rename is something easy to do before
integrating it2 into default branch. This change will break the source
compatibility between lambda/lambda and lambda/it2, but there is no
source compatibility there anyway.
It's your call though.
On 08/31/2012 09:14 PM, Brian Goetz wrote:
> Yes, the naming of these methods is a rats nest of inconsistency.
> When converting a Foo to a Bar, there are three naming conventions (all
> of which are used in the JDK):
> Traditionally, the choice of which to use is a fuzzy one, but between
> to/as mostly centers around the conceptual weight of the transformation;
> converting a List to an array is a deep-copy operation, and hence is
> called toArray, while converting an array to a List is a simple wrapper,
> and hence is called asList. However it is not a difficult search
> problem to find inconsistencies (or examples where something started out
> as one but morphed to the other), so these rules are simply suggestions
> and approximations.
> The "naked" bar() approach works seems to work well with aggregates,
> such as:
> Reader.lines() // returns Stream<String>
> String.chars() // returns IntStream
> The Arrays.asStream() example is a good example of being caught in
> existing inconsistencies; while we'd like that to be Arrays.stream() (to
> be consistent with our desired naming for collections), then we're
> inconsistent with Arrays.asList.
> Similarly, while sequential() seems a more obvious counterpart to
> parallel() from the perspective of the stream framework, it is not
> necessarily the best counterpart from the perspective of the user. After
> all, most Java collections are already sequential; calling
> "collection.sequential()" does not make it obvious what the point of
> calling sequential() is.
> Our plan with naming is to do a more global review at the point where
> we've fleshed out the functionality; these things are best done globally
> rather than locally.
> On 8/31/2012 12:14 PM, Aleksey Shipilev wrote:
>> I found the inconsistency in API for Arrays in it2 branch:
>> Arrays.asList(T... t) // returns List<T>
>> Arrays.parallel(T t) // returns Stream<T> (parallel)
>> Arrays.asStream(T... t) // returns Stream<T> (sequential?)
>> Two basic options:
>> - rename parallel() to asParallel() or asParallelStream().
>> - rename asStream() to sequential()
>> Also can be the mixture of both.
More information about the lambda-dev