SortedMap.transformValues?

[Brian Goetz]

For the "imperative" and "sequential collect" way, the ctor will be 
invoked once, because both are sequential.

For the "concurrent" way, again there is only one map; multiple threads 
blast values into the thread-safe map and we hope that the map's 
internal contention management makes that a win.

For the "parallel functional" way, yes, you are right, but the ability 
to use a different ctor for root and leaves would complicate the API 
quite a bit.

On 2/9/2013 5:23 PM, Michael Nascimento wrote:
> Thanks a lot Brian for the prompt response. I do still have a question
> though: if I got it right,  the constructor will be invoked potentially
> several times. That being true, wouldn't using HashMap::new and wrapping
> the return in a TreeMap as a final step likely be better performant?
>
> Regards,
> Michael
>
> On 8 Feb 2013 16:10, "Brian Goetz" <brian.goetz at oracle.com
> <mailto:brian.goetz at oracle.com>> wrote:
>
>     Well, it would if I wrote it right.  Let's try this again.
>
>       // Imperative way:
>       Map<K,V1> oldMap = ...
>       Map<K,V2> newMap = new TreeMap<K,V1>();
>       oldMap.entrySet().stream()
>             .forEach(e -> newMap.put(e.getKey(), f.apply(e.getvalue()));
>
>       // Collect way:
>       Map<K,V2> newMap
>            = oldMap.entrySet().stream()
>                    .collect(joiningWith(k -> f.apply(oldMap.get(k)),
>                             TreeMap::new);
>
>     To which I'll add:
>       // Concurrent way:
>       Map<K,V1> oldMap = ...
>       Map<K,V2> newMap = new ConcurrentSkipListMap<K,V1>();
>       oldMap.entrySet().__parallelStream()
>             .forEach(e -> newMap.put(e.getKey(), f.apply(e.getvalue()));
>
>       // Parallel functional way with map merging:
>       Map<K,V2> newMap
>            = oldMap.entrySet().__parallelStream()
>                    .collect(joiningWith(k -> f.apply(oldMap.get(k)),
>                             TreeMap::new)));
>
>
>     Is that enough choices?  :)
>
>     On 2/8/2013 12:59 PM, Michael Nascimento wrote:
>
>         Thank you Brian, but this does not return a SortedMap. I can always
>         construct a new one with the result, but I wonder if that is the
>         best
>         approach.
>
>         Regards,
>         Michael
>
>         On Fri, Feb 8, 2013 at 3:27 PM, Brian Goetz
>         <brian.goetz at oracle.com <mailto:brian.goetz at oracle.com>> wrote:
>
>             Er, the second example should be "keys()" not "entrySet()".
>               Sorry.
>
>
>             On 2/8/2013 11:58 AM, Brian Goetz wrote:
>
>
>                 // Imperative way:
>                 Map<K,V1> oldMap = ...
>                 Map<K,V2> newMap
>                       = oldMap.entrySet().stream()
>                               .forEach(e -> newMap.put(e.getKey(),
>                 f.apply(e.getvalue()));
>
>                 // Collector way (works in parallel!)
>                 Map<K,V2> newMap
>                       = oldMap.entrySet().stream()
>                               .collect(joiningWith(k ->
>                 f.apply(oldMap.get(k)));
>
>
>                 On 2/8/2013 11:42 AM, Michael Nascimento wrote:
>
>
>                     Any chance of getting an updated version for b76?
>
>                     On Wed, Jan 16, 2013 at 3:57 PM, Michael Nascimento
>                     <misterm at gmail.com <mailto:misterm at gmail.com>>
>                     wrote:
>
>
>                         Hi guys,
>
>                         What is the lambda way of achieving:
>
>
>                         http://docs.guava-libraries.__googlecode.com/git/javadoc/__com/google/common/collect/__Maps.html#transformValues(__java.util.SortedMap
>                         <http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Maps.html#transformValues(java.util.SortedMap>,
>                         com.google.common.base.__Function)
>
>                         ?
>
>                         Regards,
>                         Michael
>
>
>
>
>