ConcurrentHashMap/ConcurrentMap/Map.compute

[Raab, Donald]

> >
> >      <P> V getIfAbsentPutWith(K key, Function<? super P, ? extends V>
> > function, P parameter);
> >
> 
> I'd normally side with ugly-but-clear. But I think this is too far past
> merely ugly even for me :-)
> 
> -Doug

The "With" methods are certainly ugly.  But we use them consistently across GS Collections to create more opportunities for anonymous and inner class instances to be held in static variables.  We also have selectWith, rejectWith, collectWith, etc.

The "With" signals "ugly optimization here".  If you want something optimized, you must not mind it being more ugly.  :-)

Here's a simple example of allSatisfyWith.

    public boolean containsAll(Collection<?> source)
    {
        return Iterate.allSatisfyWith(source, Predicates2.in(), this);
    }

The result of Predicates2.in() is a static instance of a two argument predicate.  The predicate will be passed "each" and the reference to "this" which is the collection implementing containsAll.  This could have been written as just allSatisfy as follows:

    public boolean containsAll(Collection<?> source)
    {
        return Iterate.allSatisfy (source, Predicates.in(this));
    }

The difference here is that Predicates.in(this) has to create a new instance.

We use the specific method you highlighted in our AbstractMutableMultimap class.

    public boolean put(K key, V value)
    {
        C collection = this.getIfAbsentPutCollection(key);

        if (collection.add(value))
        {
            this.incrementTotalSize();
            return true;
        }
        return false;
    }

    private C getIfAbsentPutCollection(K key)
    {
        return this.map.getIfAbsentPutWith(key, this.createCollectionBlock(), this);
    }

The createCollectionBlock() will return the same static instance here for all multimaps.  This means every call to put doesn't create a function unnecessarily.