Original comment posted by cgdecker@google.com on 2013-11-18 at 05:53 PM

A Java 8 version of Guava is a long ways off at this point, as Guava currently still targets Java 6. Java 8 will also require major changes to Guava given that many new things it provides are similar or equivalent to things in Guava.

This is definitely something that's on our radar for things we do want to add, though. It probably wouldn't be in the form of a change to any of the ImmutableCollection Builders, but just a new set of Collectors for creating ImmutableCollections.

Status: Research
Labels: Package-Collect, Type-Addition

Original comment posted by lowasser@google.com on 2013-11-18 at 10:28 PM

FWIW, even today you can use Collectors.collectingAndThen(Collectors.toList(), ImmutableList::copyOf), which is not at all an unreasonable implementation generally speaking.

Original comment posted by sim.herter on 2014-08-18 at 08:25 PM

Is there any reason to favor stream.collect(Collectors.collectingAndThen(Collectors.toList(), ImmutableList::copyOf) ) over ImmutableList.copyOf(stream.iterator())?
The first one seems to be a more functional approach (and I looove programming in functional style with JDK8!), but since I see this a lot in my code I think I would prefer the shorter one if nothing technical speaks against it.

Original comment posted by lowasser@google.com on 2014-08-18 at 08:28 PM

The former would probably work better if your stream is parallel, and I don't think it's any less efficient in general.

The first two suggestions, repeated below, could be done to help support Java 8 users without needing "a Java 8 version of Guava" (or at least what I choose to interpret from that statement, anyway) - is there a philosophical (or otherwise) objection to folding that in?

• Make the Builder itself Iterable, so that it can be added to its own addAll-Method.
• Add another addAll-Method overload to ImmutableCollection.Builder which accepts any ImmutableCollection.Builder.

I was wondering, why is stream.collect(Collectors.collectingAndThen(Collectors.toList(), ImmutableList::copyOf)) the same efficiency as ImmutableList.copyOf(stream.iterator())?

It sounds like the first approach requires building an array, then copying the array into an ImmutableList whereas the second approach only builds the array once.

Both approaches are going to put the stream into a ArrayList-like structure, and then copy it into the ImmutableList. ImmutableList.copyOf(Iterator) delegates to ImmutableList.Builder, which is built as approximately a specialized ArrayList.

I see, thanks for the help =)

I don't think that's 100% true. ImmutableList.copyOf(stream.iterator()) is more efficient for the special case of an iterator yielding only 0 or 1 elements, where it avoids allocating the intermediary ArrayList.

We have a plan we're working on to use collectors w/ immutable collections and it'll be addresses in an upcoming version of Guava that supports Java8.

+1

Would love to see this added into the core guava codebase. Any traction on this yet?

The immutable collections now have built-in collectors that will be included in the Guava 21 release. I think we can actually call this closed?

(We haven't exposed collector-ness in the builders themselves, just collectors, but I think that's what we'd prefer unless we hear compelling reasons to add them into the builders.)