java.lang.Object
- org.eclipse.collections.impl.map.mutable.primitive.DoubleObjectHashMap<V>

All Implemented Interfaces:

Externalizable, Serializable, Iterable<V>, InternalIterable<V>, DoubleObjectMap<V>, MutableDoubleObjectMap<V>, MutablePrimitiveObjectMap<V>, PrimitiveObjectMap<V>, RichIterable<V>
```
public class DoubleObjectHashMap<V>
extends Object
implements MutableDoubleObjectMap<V>, Externalizable
```
This file was automatically generated from template file primitiveObjectHashMap.stg.

Since:

3.0.

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor Description

DoubleObjectHashMap()

DoubleObjectHashMap(int initialCapacity)

DoubleObjectHashMap(DoubleObjectMap<? extends V> map)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`<K,VV> MutableMap<K,VV>`	`aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)`
`boolean`	`allSatisfy(Predicate<? super V> predicate)`
`<P> boolean`	`allSatisfyWith(Predicate2<? super V,? super P> predicate, P parameter)`
`boolean`	`anySatisfy(Predicate<? super V> predicate)`
`<P> boolean`	`anySatisfyWith(Predicate2<? super V,? super P> predicate, P parameter)`
`void`	`appendString(Appendable appendable)`
`void`	`appendString(Appendable appendable, String separator)`
`void`	`appendString(Appendable appendable, String start, String separator, String end)`
`LazyIterable<V>`	`asLazy()`
`MutableDoubleObjectMap<V>`	`asSynchronized()`
`MutableDoubleObjectMap<V>`	`asUnmodifiable()`
`RichIterable<RichIterable<V>>`	`chunk(int size)`
`void`	`clear()`
`<VV> MutableBag<VV>`	`collect(Function<? super V,? extends VV> function)`
`<VV,R extends Collection<VV>> R`	`collect(Function<? super V,? extends VV> function, R target)`
`MutableBooleanBag`	`collectBoolean(BooleanFunction<? super V> booleanFunction)`
`MutableByteBag`	`collectByte(ByteFunction<? super V> byteFunction)`
`MutableCharBag`	`collectChar(CharFunction<? super V> charFunction)`
`MutableDoubleBag`	`collectDouble(DoubleFunction<? super V> doubleFunction)`
`MutableFloatBag`	`collectFloat(FloatFunction<? super V> floatFunction)`
`<VV> MutableBag<VV>`	`collectIf(Predicate<? super V> predicate, Function<? super V,? extends VV> function)`
`<VV,R extends Collection<VV>> R`	`collectIf(Predicate<? super V> predicate, Function<? super V,? extends VV> function, R target)`
`MutableIntBag`	`collectInt(IntFunction<? super V> intFunction)`
`MutableLongBag`	`collectLong(LongFunction<? super V> longFunction)`
`MutableShortBag`	`collectShort(ShortFunction<? super V> shortFunction)`
`<P,VV> MutableBag<VV>`	`collectWith(Function2<? super V,? super P,? extends VV> function, P parameter)`
`<P,VV,R extends Collection<VV>> R`	`collectWith(Function2<? super V,? super P,? extends VV> function, P parameter, R targetCollection)`
`void`	`compact()`	Deprecated. since 12.0 - Use `trimToSize()` instead
`boolean`	`contains(Object object)`
`boolean`	`containsAll(Collection<?> source)`
`boolean`	`containsAllArguments(Object... elements)`
`boolean`	`containsAllIterable(Iterable<?> source)`
`boolean`	`containsKey(double key)`
`boolean`	`containsValue(Object value)`
`int`	`count(Predicate<? super V> predicate)`
`<P> int`	`countWith(Predicate2<? super V,? super P> predicate, P parameter)`
`V`	`detect(Predicate<? super V> predicate)`
`V`	`detectIfNone(Predicate<? super V> predicate, Function0<? extends V> function)`
`Optional<V>`	`detectOptional(Predicate<? super V> predicate)`
`<P> V`	`detectWith(Predicate2<? super V,? super P> predicate, P parameter)`
`<P> V`	`detectWithIfNone(Predicate2<? super V,? super P> predicate, P parameter, Function0<? extends V> function)`
`<P> Optional<V>`	`detectWithOptional(Predicate2<? super V,? super P> predicate, P parameter)`
`void`	`each(Procedure<? super V> procedure)`
`boolean`	`equals(Object obj)`
`<VV> MutableBag<VV>`	`flatCollect(Function<? super V,? extends Iterable<VV>> function)`
`<VV,R extends Collection<VV>> R`	`flatCollect(Function<? super V,? extends Iterable<VV>> function, R target)`
`MutableObjectDoubleMap<V>`	`flipUniqueValues()`
`void`	`forEachKey(DoubleProcedure procedure)`
`void`	`forEachKeyValue(DoubleObjectProcedure<? super V> procedure)`
`void`	`forEachValue(Procedure<? super V> procedure)`
`<P> void`	`forEachWith(Procedure2<? super V,? super P> procedure, P parameter)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)`
`V`	`get(double key)`
`V`	`getFirst()`
`V`	`getIfAbsent(double key, Function0<? extends V> ifAbsent)`
`V`	`getIfAbsentPut(double key, Function0<? extends V> function)`
`V`	`getIfAbsentPut(double key, V value)`
`<P> V`	`getIfAbsentPutWith(double key, Function<? super P,? extends V> function, P parameter)`
`V`	`getIfAbsentPutWithKey(double key, DoubleToObjectFunction<? extends V> function)`
`V`	`getLast()`
`V`	`getOnly()`
`<VV> MutableBagMultimap<VV,V>`	`groupBy(Function<? super V,? extends VV> function)`
`<VV,R extends MutableMultimap<VV,V>> R`	`groupBy(Function<? super V,? extends VV> function, R target)`
`<VV> MutableBagMultimap<VV,V>`	`groupByEach(Function<? super V,? extends Iterable<VV>> function)`
`<VV,R extends MutableMultimap<VV,V>> R`	`groupByEach(Function<? super V,? extends Iterable<VV>> function, R target)`
`<VV> MutableMap<VV,V>`	`groupByUniqueKey(Function<? super V,? extends VV> function)`
`<VV,R extends MutableMapIterable<VV,V>> R`	`groupByUniqueKey(Function<? super V,? extends VV> function, R target)`
`int`	`hashCode()`
`double`	`injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super V> function)`
`float`	`injectInto(float injectedValue, FloatObjectToFloatFunction<? super V> function)`
`int`	`injectInto(int injectedValue, IntObjectToIntFunction<? super V> function)`
`long`	`injectInto(long injectedValue, LongObjectToLongFunction<? super V> function)`
`<IV> IV`	`injectInto(IV injectedValue, Function2<? super IV,? super V,? extends IV> function)`
`<R extends Collection<V>> R`	`into(R target)`
`boolean`	`isEmpty()`
`Iterator<V>`	`iterator()`
`MutableDoubleSet`	`keySet()`
`LazyDoubleIterable`	`keysView()`
`RichIterable<DoubleObjectPair<V>>`	`keyValuesView()`
`String`	`makeString()`
`String`	`makeString(String separator)`
`String`	`makeString(String start, String separator, String end)`
`V`	`max()`
`V`	`max(Comparator<? super V> comparator)`
`<VV extends Comparable<? super VV>> V`	`maxBy(Function<? super V,? extends VV> function)`
`V`	`min()`
`V`	`min(Comparator<? super V> comparator)`
`<VV extends Comparable<? super VV>> V`	`minBy(Function<? super V,? extends VV> function)`
`static <V> DoubleObjectHashMap<V>`	`newMap()`
`static <V> DoubleObjectHashMap<V>`	`newMap(DoubleObjectMap<? extends V> map)`
`static <V> DoubleObjectHashMap<V>`	`newWithKeysValues(double key, V value)`
`static <V> DoubleObjectHashMap<V>`	`newWithKeysValues(double key1, V value1, double key2, V value2)`
`static <V> DoubleObjectHashMap<V>`	`newWithKeysValues(double key1, V value1, double key2, V value2, double key3, V value3)`
`static <V> DoubleObjectHashMap<V>`	`newWithKeysValues(double key1, V value1, double key2, V value2, double key3, V value3, double key4, V value4)`
`boolean`	`noneSatisfy(Predicate<? super V> predicate)`
`<P> boolean`	`noneSatisfyWith(Predicate2<? super V,? super P> predicate, P parameter)`
`boolean`	`notEmpty()`
`PartitionMutableBag<V>`	`partition(Predicate<? super V> predicate)`
`<P> PartitionMutableBag<V>`	`partitionWith(Predicate2<? super V,? super P> predicate, P parameter)`
`V`	`put(double key, V value)`
`void`	`putAll(DoubleObjectMap<? extends V> map)`
`void`	`readExternal(ObjectInput in)`
`MutableBag<V>`	`reject(Predicate<? super V> predicate)`
`<R extends Collection<V>> R`	`reject(Predicate<? super V> predicate, R target)`
`DoubleObjectHashMap<V>`	`reject(DoubleObjectPredicate<? super V> predicate)`
`<P> MutableBag<V>`	`rejectWith(Predicate2<? super V,? super P> predicate, P parameter)`
`<P,R extends Collection<V>> R`	`rejectWith(Predicate2<? super V,? super P> predicate, P parameter, R targetCollection)`
`V`	`remove(double key)`
`boolean`	`removeIf(DoubleObjectPredicate<? super V> predicate)`
`V`	`removeKey(double key)`
`MutableBag<V>`	`select(Predicate<? super V> predicate)`
`<R extends Collection<V>> R`	`select(Predicate<? super V> predicate, R target)`
`DoubleObjectHashMap<V>`	`select(DoubleObjectPredicate<? super V> predicate)`
`<S> MutableBag<S>`	`selectInstancesOf(Class<S> clazz)`
`<P> MutableBag<V>`	`selectWith(Predicate2<? super V,? super P> predicate, P parameter)`
`<P,R extends Collection<V>> R`	`selectWith(Predicate2<? super V,? super P> predicate, P parameter, R targetCollection)`
`int`	`size()`
`<V1> MutableObjectDoubleMap<V1>`	`sumByDouble(Function<? super V,? extends V1> groupBy, DoubleFunction<? super V> function)`
`<V1> MutableObjectDoubleMap<V1>`	`sumByFloat(Function<? super V,? extends V1> groupBy, FloatFunction<? super V> function)`
`<V1> MutableObjectLongMap<V1>`	`sumByInt(Function<? super V,? extends V1> groupBy, IntFunction<? super V> function)`
`<V1> MutableObjectLongMap<V1>`	`sumByLong(Function<? super V,? extends V1> groupBy, LongFunction<? super V> function)`
`double`	`sumOfDouble(DoubleFunction<? super V> function)`
`double`	`sumOfFloat(FloatFunction<? super V> function)`
`long`	`sumOfInt(IntFunction<? super V> function)`
`long`	`sumOfLong(LongFunction<? super V> function)`
`DoubleObjectHashMap<V>`	`tap(Procedure<? super V> procedure)`
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`MutableBag<V>`	`toBag()`
`<NK,NV> MutableBiMap<NK,NV>`	`toBiMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)`
`ImmutableDoubleObjectMap<V>`	`toImmutable()`
`MutableList<V>`	`toList()`
`<NK,NV> MutableMap<NK,NV>`	`toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)`
`MutableSet<V>`	`toSet()`
`MutableSortedBag<V>`	`toSortedBag()`
`MutableSortedBag<V>`	`toSortedBag(Comparator<? super V> comparator)`
`<NK,NV> MutableSortedMap<NK,NV>`	`toSortedMap(Comparator<? super NK> comparator, Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)`
`<NK,NV> MutableSortedMap<NK,NV>`	`toSortedMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)`
`MutableSortedSet<V>`	`toSortedSet()`
`MutableSortedSet<V>`	`toSortedSet(Comparator<? super V> comparator)`
`String`	`toString()`
`boolean`	`trimToSize()`
`V`	`updateValue(double key, Function0<? extends V> factory, Function<? super V,? extends V> function)`
`<P> V`	`updateValueWith(double key, Function0<? extends V> factory, Function2<? super V,? super P,? extends V> function, P parameter)`
`Collection<V>`	`values()`
`DoubleObjectHashMap<V>`	`withKeysValues(double key1, V value1, double key2, V value2)`
`DoubleObjectHashMap<V>`	`withKeysValues(double key1, V value1, double key2, V value2, double key3, V value3)`
`DoubleObjectHashMap<V>`	`withKeysValues(double key1, V value1, double key2, V value2, double key3, V value3, double key4, V value4)`
`DoubleObjectHashMap<V>`	`withKeyValue(double key, V value)`
`MutableDoubleObjectMap<V>`	`withoutAllKeys(DoubleIterable keys)`
`MutableDoubleObjectMap<V>`	`withoutKey(double key)`
`void`	`writeExternal(ObjectOutput out)`
`<S> MutableBag<Pair<V,S>>`	`zip(Iterable<S> that)`	Deprecated. in 7.0.
`<S,R extends Collection<Pair<V,S>>> R`	`zip(Iterable<S> that, R target)`
`MutableSet<Pair<V,Integer>>`	`zipWithIndex()`	Deprecated. in 7.0.
`<R extends Collection<Pair<V,Integer>>> R`	`zipWithIndex(R target)`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.collections.api.map.primitive.DoubleObjectMap
injectIntoKeyValue

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach

Methods inherited from interface org.eclipse.collections.api.map.primitive.MutableDoubleObjectMap
putPair, withAllKeyValues

Methods inherited from interface org.eclipse.collections.api.map.primitive.MutablePrimitiveObjectMap
aggregateBy, flatCollectWith

Methods inherited from interface org.eclipse.collections.api.map.primitive.PrimitiveObjectMap
parallelStream, spliterator, stream

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, countBy, countBy, countByEach, countByEach, countByWith, countByWith, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, groupByAndCollect, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, makeString, maxByOptional, maxOptional, maxOptional, minByOptional, minOptional, minOptional, reduce, reduceInPlace, reduceInPlace, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toMap, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMapBy, toSortedSetBy

Constructor Detail

DoubleObjectHashMap
```
public DoubleObjectHashMap()
```

DoubleObjectHashMap

public DoubleObjectHashMap(int initialCapacity)

DoubleObjectHashMap

public DoubleObjectHashMap(DoubleObjectMap<? extends V> map)

Method Detail

newMap

public static <V> DoubleObjectHashMap<V> newMap()

newMap

public static <V> DoubleObjectHashMap<V> newMap(DoubleObjectMap<? extends V> map)

newWithKeysValues

public static <V> DoubleObjectHashMap<V> newWithKeysValues(double key,
                                                           V value)

newWithKeysValues

public static <V> DoubleObjectHashMap<V> newWithKeysValues(double key1,
                                                           V value1,
                                                           double key2,
                                                           V value2)

newWithKeysValues

public static <V> DoubleObjectHashMap<V> newWithKeysValues(double key1,
                                                           V value1,
                                                           double key2,
                                                           V value2,
                                                           double key3,
                                                           V value3)

newWithKeysValues

public static <V> DoubleObjectHashMap<V> newWithKeysValues(double key1,
                                                           V value1,
                                                           double key2,
                                                           V value2,
                                                           double key3,
                                                           V value3,
                                                           double key4,
                                                           V value4)

equals
```
public boolean equals(Object obj)
```
Specified by:

equals in interface PrimitiveObjectMap<V>

Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Specified by:

hashCode in interface PrimitiveObjectMap<V>

Overrides:

hashCode in class Object

toString
```
public String toString()
```
Specified by:

toString in interface PrimitiveObjectMap<V>

Specified by:

toString in interface RichIterable<V>

Overrides:

toString in class Object

size
```
public int size()
```
Specified by:

size in interface RichIterable<V>

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in interface RichIterable<V>

notEmpty
```
public boolean notEmpty()
```
Specified by:

notEmpty in interface RichIterable<V>

makeString
```
public String makeString()
```
Specified by:

makeString in interface RichIterable<V>

makeString
```
public String makeString(String separator)
```
Specified by:

makeString in interface RichIterable<V>

makeString

public String makeString(String start,
                         String separator,
                         String end)

Specified by:: makeString in interface RichIterable<V>

appendString
```
public void appendString(Appendable appendable)
```
Specified by:

appendString in interface RichIterable<V>

appendString

public void appendString(Appendable appendable,
                         String separator)

Specified by:: appendString in interface RichIterable<V>

appendString

public void appendString(Appendable appendable,
                         String start,
                         String separator,
                         String end)

Specified by:: appendString in interface RichIterable<V>

iterator
```
public Iterator<V> iterator()
```
Specified by:

iterator in interface Iterable<V>

toArray
```
public Object[] toArray()
```
Specified by:

toArray in interface RichIterable<V>

toArray
```
public <T> T[] toArray(T[] a)
```
Specified by:

toArray in interface RichIterable<V>

contains
```
public boolean contains(Object object)
```
Specified by:

contains in interface RichIterable<V>

containsAllIterable
```
public boolean containsAllIterable(Iterable<?> source)
```
Specified by:

containsAllIterable in interface RichIterable<V>

containsAll
```
public boolean containsAll(Collection<?> source)
```
Specified by:

containsAll in interface RichIterable<V>

containsAllArguments
```
public boolean containsAllArguments(Object... elements)
```
Specified by:

containsAllArguments in interface RichIterable<V>

tap
```
public DoubleObjectHashMap<V> tap(Procedure<? super V> procedure)
```
Specified by:

tap in interface DoubleObjectMap<V>

Specified by:

tap in interface MutableDoubleObjectMap<V>

Specified by:

tap in interface RichIterable<V>

each

public void each(Procedure<? super V> procedure)

Specified by:: each in interface RichIterable<V>

forEachWithIndex

public void forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)

Specified by:: forEachWithIndex in interface InternalIterable<V>

forEachWith

public <P> void forEachWith(Procedure2<? super V,? super P> procedure,
                            P parameter)

Specified by:: forEachWith in interface InternalIterable<V>

forEachValue
```
public void forEachValue(Procedure<? super V> procedure)
```
Specified by:

forEachValue in interface PrimitiveObjectMap<V>

forEachKey
```
public void forEachKey(DoubleProcedure procedure)
```
Specified by:

forEachKey in interface DoubleObjectMap<V>

forEachKeyValue

public void forEachKeyValue(DoubleObjectProcedure<? super V> procedure)

Specified by:: forEachKeyValue in interface DoubleObjectMap<V>

select
```
public DoubleObjectHashMap<V> select(DoubleObjectPredicate<? super V> predicate)
```
Specified by:

select in interface DoubleObjectMap<V>

Specified by:

select in interface MutableDoubleObjectMap<V>

reject
```
public DoubleObjectHashMap<V> reject(DoubleObjectPredicate<? super V> predicate)
```
Specified by:

reject in interface DoubleObjectMap<V>

Specified by:

reject in interface MutableDoubleObjectMap<V>

select
```
public MutableBag<V> select(Predicate<? super V> predicate)
```
Specified by:

select in interface MutablePrimitiveObjectMap<V>

Specified by:

select in interface PrimitiveObjectMap<V>

Specified by:

select in interface RichIterable<V>

select

public <R extends Collection<V>> R select(Predicate<? super V> predicate,
                                          R target)

Specified by:: select in interface RichIterable<V>

selectWith
```
public <P> MutableBag<V> selectWith(Predicate2<? super V,? super P> predicate,
                                    P parameter)
```
Specified by:

selectWith in interface MutablePrimitiveObjectMap<V>

Specified by:

selectWith in interface PrimitiveObjectMap<V>

Specified by:

selectWith in interface RichIterable<V>

selectWith

public <P,R extends Collection<V>> R selectWith(Predicate2<? super V,? super P> predicate,
                                                      P parameter,
                                                      R targetCollection)

Specified by:: selectWith in interface RichIterable<V>

reject
```
public MutableBag<V> reject(Predicate<? super V> predicate)
```
Specified by:

reject in interface MutablePrimitiveObjectMap<V>

Specified by:

reject in interface PrimitiveObjectMap<V>

Specified by:

reject in interface RichIterable<V>

reject

public <R extends Collection<V>> R reject(Predicate<? super V> predicate,
                                          R target)

Specified by:: reject in interface RichIterable<V>

rejectWith
```
public <P> MutableBag<V> rejectWith(Predicate2<? super V,? super P> predicate,
                                    P parameter)
```
Specified by:

rejectWith in interface MutablePrimitiveObjectMap<V>

Specified by:

rejectWith in interface PrimitiveObjectMap<V>

Specified by:

rejectWith in interface RichIterable<V>

rejectWith

public <P,R extends Collection<V>> R rejectWith(Predicate2<? super V,? super P> predicate,
                                                      P parameter,
                                                      R targetCollection)

Specified by:: rejectWith in interface RichIterable<V>

partition
```
public PartitionMutableBag<V> partition(Predicate<? super V> predicate)
```
Specified by:

partition in interface MutablePrimitiveObjectMap<V>

Specified by:

partition in interface PrimitiveObjectMap<V>

Specified by:

partition in interface RichIterable<V>

partitionWith
```
public <P> PartitionMutableBag<V> partitionWith(Predicate2<? super V,? super P> predicate,
                                                P parameter)
```
Specified by:

partitionWith in interface MutablePrimitiveObjectMap<V>

Specified by:

partitionWith in interface PrimitiveObjectMap<V>

Specified by:

partitionWith in interface RichIterable<V>

selectInstancesOf
```
public <S> MutableBag<S> selectInstancesOf(Class<S> clazz)
```
Specified by:

selectInstancesOf in interface MutablePrimitiveObjectMap<V>

Specified by:

selectInstancesOf in interface PrimitiveObjectMap<V>

Specified by:

selectInstancesOf in interface RichIterable<V>

collect
```
public <VV> MutableBag<VV> collect(Function<? super V,? extends VV> function)
```
Specified by:

collect in interface MutablePrimitiveObjectMap<V>

Specified by:

collect in interface PrimitiveObjectMap<V>

Specified by:

collect in interface RichIterable<V>

collectBoolean
```
public MutableBooleanBag collectBoolean(BooleanFunction<? super V> booleanFunction)
```
Specified by:

collectBoolean in interface MutablePrimitiveObjectMap<V>

Specified by:

collectBoolean in interface PrimitiveObjectMap<V>

Specified by:

collectBoolean in interface RichIterable<V>

collectByte
```
public MutableByteBag collectByte(ByteFunction<? super V> byteFunction)
```
Specified by:

collectByte in interface MutablePrimitiveObjectMap<V>

Specified by:

collectByte in interface PrimitiveObjectMap<V>

Specified by:

collectByte in interface RichIterable<V>

collectChar
```
public MutableCharBag collectChar(CharFunction<? super V> charFunction)
```
Specified by:

collectChar in interface MutablePrimitiveObjectMap<V>

Specified by:

collectChar in interface PrimitiveObjectMap<V>

Specified by:

collectChar in interface RichIterable<V>

collectDouble
```
public MutableDoubleBag collectDouble(DoubleFunction<? super V> doubleFunction)
```
Specified by:

collectDouble in interface MutablePrimitiveObjectMap<V>

Specified by:

collectDouble in interface PrimitiveObjectMap<V>

Specified by:

collectDouble in interface RichIterable<V>

collectFloat
```
public MutableFloatBag collectFloat(FloatFunction<? super V> floatFunction)
```
Specified by:

collectFloat in interface MutablePrimitiveObjectMap<V>

Specified by:

collectFloat in interface PrimitiveObjectMap<V>

Specified by:

collectFloat in interface RichIterable<V>

collectInt
```
public MutableIntBag collectInt(IntFunction<? super V> intFunction)
```
Specified by:

collectInt in interface MutablePrimitiveObjectMap<V>

Specified by:

collectInt in interface PrimitiveObjectMap<V>

Specified by:

collectInt in interface RichIterable<V>

collectLong
```
public MutableLongBag collectLong(LongFunction<? super V> longFunction)
```
Specified by:

collectLong in interface MutablePrimitiveObjectMap<V>

Specified by:

collectLong in interface PrimitiveObjectMap<V>

Specified by:

collectLong in interface RichIterable<V>

collectShort
```
public MutableShortBag collectShort(ShortFunction<? super V> shortFunction)
```
Specified by:

collectShort in interface MutablePrimitiveObjectMap<V>

Specified by:

collectShort in interface PrimitiveObjectMap<V>

Specified by:

collectShort in interface RichIterable<V>

collectWith
```
public <P,VV> MutableBag<VV> collectWith(Function2<? super V,? super P,? extends VV> function,
                                               P parameter)
```
Specified by:

collectWith in interface MutablePrimitiveObjectMap<V>

Specified by:

collectWith in interface PrimitiveObjectMap<V>

Specified by:

collectWith in interface RichIterable<V>

collectWith

public <P,VV,R extends Collection<VV>> R collectWith(Function2<? super V,? super P,? extends VV> function,
                                                                 P parameter,
                                                                 R targetCollection)

Specified by:: collectWith in interface RichIterable<V>

collect

public <VV,R extends Collection<VV>> R collect(Function<? super V,? extends VV> function,
                                                     R target)

Specified by:: collect in interface RichIterable<V>

collectIf

public <VV> MutableBag<VV> collectIf(Predicate<? super V> predicate,
                                     Function<? super V,? extends VV> function)

Specified by:: collectIf in interface MutablePrimitiveObjectMap<V>
Specified by:: collectIf in interface PrimitiveObjectMap<V>
Specified by:: collectIf in interface RichIterable<V>

collectIf

public <VV,R extends Collection<VV>> R collectIf(Predicate<? super V> predicate,
                                                       Function<? super V,? extends VV> function,
                                                       R target)

Specified by:: collectIf in interface RichIterable<V>

flatCollect
```
public <VV> MutableBag<VV> flatCollect(Function<? super V,? extends Iterable<VV>> function)
```
Specified by:

flatCollect in interface MutablePrimitiveObjectMap<V>

Specified by:

flatCollect in interface PrimitiveObjectMap<V>

Specified by:

flatCollect in interface RichIterable<V>

flatCollect

public <VV,R extends Collection<VV>> R flatCollect(Function<? super V,? extends Iterable<VV>> function,
                                                         R target)

Specified by:: flatCollect in interface RichIterable<V>

detect

public V detect(Predicate<? super V> predicate)

Specified by:: detect in interface RichIterable<V>

detectWith

public <P> V detectWith(Predicate2<? super V,? super P> predicate,
                        P parameter)

Specified by:: detectWith in interface RichIterable<V>

detectOptional

public Optional<V> detectOptional(Predicate<? super V> predicate)

Specified by:: detectOptional in interface RichIterable<V>

detectWithOptional

public <P> Optional<V> detectWithOptional(Predicate2<? super V,? super P> predicate,
                                          P parameter)

Specified by:: detectWithOptional in interface RichIterable<V>

detectIfNone

public V detectIfNone(Predicate<? super V> predicate,
                      Function0<? extends V> function)

Specified by:: detectIfNone in interface RichIterable<V>

detectWithIfNone

public <P> V detectWithIfNone(Predicate2<? super V,? super P> predicate,
                              P parameter,
                              Function0<? extends V> function)

Specified by:: detectWithIfNone in interface RichIterable<V>

count

public int count(Predicate<? super V> predicate)

Specified by:: count in interface RichIterable<V>

countWith

public <P> int countWith(Predicate2<? super V,? super P> predicate,
                         P parameter)

Specified by:: countWith in interface RichIterable<V>

anySatisfy

public boolean anySatisfy(Predicate<? super V> predicate)

Specified by:: anySatisfy in interface RichIterable<V>

anySatisfyWith

public <P> boolean anySatisfyWith(Predicate2<? super V,? super P> predicate,
                                  P parameter)

Specified by:: anySatisfyWith in interface RichIterable<V>

allSatisfy

public boolean allSatisfy(Predicate<? super V> predicate)

Specified by:: allSatisfy in interface RichIterable<V>

allSatisfyWith

public <P> boolean allSatisfyWith(Predicate2<? super V,? super P> predicate,
                                  P parameter)

Specified by:: allSatisfyWith in interface RichIterable<V>

noneSatisfy

public boolean noneSatisfy(Predicate<? super V> predicate)

Specified by:: noneSatisfy in interface RichIterable<V>

noneSatisfyWith

public <P> boolean noneSatisfyWith(Predicate2<? super V,? super P> predicate,
                                   P parameter)

Specified by:: noneSatisfyWith in interface RichIterable<V>

injectInto

public <IV> IV injectInto(IV injectedValue,
                          Function2<? super IV,? super V,? extends IV> function)

Specified by:: injectInto in interface RichIterable<V>

injectInto

public int injectInto(int injectedValue,
                      IntObjectToIntFunction<? super V> function)

Specified by:: injectInto in interface RichIterable<V>

injectInto

public long injectInto(long injectedValue,
                       LongObjectToLongFunction<? super V> function)

Specified by:: injectInto in interface RichIterable<V>

injectInto

public float injectInto(float injectedValue,
                        FloatObjectToFloatFunction<? super V> function)

Specified by:: injectInto in interface RichIterable<V>

injectInto

public double injectInto(double injectedValue,
                         DoubleObjectToDoubleFunction<? super V> function)

Specified by:: injectInto in interface RichIterable<V>

zip
```
@Deprecated
public <S> MutableBag<Pair<V,S>> zip(Iterable<S> that)
```
Deprecated.
in 7.0. Use OrderedIterable.zip(Iterable) instead.

Specified by:

zip in interface MutablePrimitiveObjectMap<V>

Specified by:

zip in interface PrimitiveObjectMap<V>

Specified by:

zip in interface RichIterable<V>

zip

public <S,R extends Collection<Pair<V,S>>> R zip(Iterable<S> that,
                                                             R target)

Specified by:: zip in interface RichIterable<V>

zipWithIndex
```
@Deprecated
public MutableSet<Pair<V,Integer>> zipWithIndex()
```
Deprecated.
in 7.0. Use OrderedIterable.zipWithIndex() instead.

Specified by:

zipWithIndex in interface MutablePrimitiveObjectMap<V>

Specified by:

zipWithIndex in interface PrimitiveObjectMap<V>

Specified by:

zipWithIndex in interface RichIterable<V>

zipWithIndex

public <R extends Collection<Pair<V,Integer>>> R zipWithIndex(R target)

Specified by:: zipWithIndex in interface RichIterable<V>

chunk

public RichIterable<RichIterable<V>> chunk(int size)

Specified by:: chunk in interface RichIterable<V>

aggregateInPlaceBy

public <K,VV> MutableMap<K,VV> aggregateInPlaceBy(Function<? super V,? extends K> groupBy,
                                                              Function0<? extends VV> zeroValueFactory,
                                                              Procedure2<? super VV,? super V> mutatingAggregator)

Specified by:: aggregateInPlaceBy in interface MutablePrimitiveObjectMap<V>
Specified by:: aggregateInPlaceBy in interface RichIterable<V>

groupBy
```
public <VV> MutableBagMultimap<VV,V> groupBy(Function<? super V,? extends VV> function)
```
Specified by:

groupBy in interface MutablePrimitiveObjectMap<V>

Specified by:

groupBy in interface PrimitiveObjectMap<V>

Specified by:

groupBy in interface RichIterable<V>

groupBy

public <VV,R extends MutableMultimap<VV,V>> R groupBy(Function<? super V,? extends VV> function,
                                                                  R target)

Specified by:: groupBy in interface RichIterable<V>

groupByEach
```
public <VV> MutableBagMultimap<VV,V> groupByEach(Function<? super V,? extends Iterable<VV>> function)
```
Specified by:

groupByEach in interface MutablePrimitiveObjectMap<V>

Specified by:

groupByEach in interface PrimitiveObjectMap<V>

Specified by:

groupByEach in interface RichIterable<V>

groupByEach

public <VV,R extends MutableMultimap<VV,V>> R groupByEach(Function<? super V,? extends Iterable<VV>> function,
                                                                      R target)

Specified by:: groupByEach in interface RichIterable<V>

groupByUniqueKey
```
public <VV> MutableMap<VV,V> groupByUniqueKey(Function<? super V,? extends VV> function)
```
Specified by:

groupByUniqueKey in interface MutablePrimitiveObjectMap<V>

Specified by:

groupByUniqueKey in interface PrimitiveObjectMap<V>

Specified by:

groupByUniqueKey in interface RichIterable<V>

groupByUniqueKey

public <VV,R extends MutableMapIterable<VV,V>> R groupByUniqueKey(Function<? super V,? extends VV> function,
                                                                              R target)

Specified by:: groupByUniqueKey in interface RichIterable<V>

getFirst
```
public V getFirst()
```
Specified by:

getFirst in interface RichIterable<V>

getLast
```
public V getLast()
```
Specified by:

getLast in interface RichIterable<V>

getOnly
```
public V getOnly()
```
Specified by:

getOnly in interface RichIterable<V>

toList
```
public MutableList<V> toList()
```
Specified by:

toList in interface RichIterable<V>

into

public <R extends Collection<V>> R into(R target)

Specified by:: into in interface RichIterable<V>

toSet
```
public MutableSet<V> toSet()
```
Specified by:

toSet in interface RichIterable<V>

toSortedSet
```
public MutableSortedSet<V> toSortedSet()
```
Specified by:

toSortedSet in interface RichIterable<V>

toSortedSet

public MutableSortedSet<V> toSortedSet(Comparator<? super V> comparator)

Specified by:: toSortedSet in interface RichIterable<V>

toBag
```
public MutableBag<V> toBag()
```
Specified by:

toBag in interface RichIterable<V>

toSortedBag
```
public MutableSortedBag<V> toSortedBag()
```
Specified by:

toSortedBag in interface RichIterable<V>

toSortedBag

public MutableSortedBag<V> toSortedBag(Comparator<? super V> comparator)

Specified by:: toSortedBag in interface RichIterable<V>

toMap

public <NK,NV> MutableMap<NK,NV> toMap(Function<? super V,? extends NK> keyFunction,
                                                   Function<? super V,? extends NV> valueFunction)

Specified by:: toMap in interface RichIterable<V>

toSortedMap

public <NK,NV> MutableSortedMap<NK,NV> toSortedMap(Function<? super V,? extends NK> keyFunction,
                                                               Function<? super V,? extends NV> valueFunction)

Specified by:: toSortedMap in interface RichIterable<V>

toSortedMap

public <NK,NV> MutableSortedMap<NK,NV> toSortedMap(Comparator<? super NK> comparator,
                                                               Function<? super V,? extends NK> keyFunction,
                                                               Function<? super V,? extends NV> valueFunction)

Specified by:: toSortedMap in interface RichIterable<V>

toBiMap

public <NK,NV> MutableBiMap<NK,NV> toBiMap(Function<? super V,? extends NK> keyFunction,
                                                       Function<? super V,? extends NV> valueFunction)

Specified by:: toBiMap in interface RichIterable<V>

asLazy
```
public LazyIterable<V> asLazy()
```
Specified by:

asLazy in interface RichIterable<V>

min

public V min(Comparator<? super V> comparator)

Specified by:: min in interface RichIterable<V>

max

public V max(Comparator<? super V> comparator)

Specified by:: max in interface RichIterable<V>

min
```
public V min()
```
Specified by:

min in interface RichIterable<V>

max
```
public V max()
```
Specified by:

max in interface RichIterable<V>

maxBy

public <VV extends Comparable<? super VV>> V maxBy(Function<? super V,? extends VV> function)

Specified by:: maxBy in interface RichIterable<V>

minBy

public <VV extends Comparable<? super VV>> V minBy(Function<? super V,? extends VV> function)

Specified by:: minBy in interface RichIterable<V>

sumOfInt

public long sumOfInt(IntFunction<? super V> function)

Specified by:: sumOfInt in interface RichIterable<V>

sumOfFloat

public double sumOfFloat(FloatFunction<? super V> function)

Specified by:: sumOfFloat in interface RichIterable<V>

sumOfLong

public long sumOfLong(LongFunction<? super V> function)

Specified by:: sumOfLong in interface RichIterable<V>

sumOfDouble

public double sumOfDouble(DoubleFunction<? super V> function)

Specified by:: sumOfDouble in interface RichIterable<V>

sumByInt

public <V1> MutableObjectLongMap<V1> sumByInt(Function<? super V,? extends V1> groupBy,
                                              IntFunction<? super V> function)

Specified by:: sumByInt in interface MutablePrimitiveObjectMap<V>
Specified by:: sumByInt in interface RichIterable<V>

sumByFloat

public <V1> MutableObjectDoubleMap<V1> sumByFloat(Function<? super V,? extends V1> groupBy,
                                                  FloatFunction<? super V> function)

Specified by:: sumByFloat in interface MutablePrimitiveObjectMap<V>
Specified by:: sumByFloat in interface RichIterable<V>

sumByLong

public <V1> MutableObjectLongMap<V1> sumByLong(Function<? super V,? extends V1> groupBy,
                                               LongFunction<? super V> function)

Specified by:: sumByLong in interface MutablePrimitiveObjectMap<V>
Specified by:: sumByLong in interface RichIterable<V>

sumByDouble

public <V1> MutableObjectDoubleMap<V1> sumByDouble(Function<? super V,? extends V1> groupBy,
                                                   DoubleFunction<? super V> function)

Specified by:: sumByDouble in interface MutablePrimitiveObjectMap<V>
Specified by:: sumByDouble in interface RichIterable<V>

clear
```
public void clear()
```
Specified by:

clear in interface MutablePrimitiveObjectMap<V>

put

public V put(double key,
             V value)

Specified by:: put in interface MutableDoubleObjectMap<V>

putAll
```
public void putAll(DoubleObjectMap<? extends V> map)
```
Specified by:

putAll in interface MutableDoubleObjectMap<V>

containsKey
```
public boolean containsKey(double key)
```
Specified by:

containsKey in interface DoubleObjectMap<V>

containsValue
```
public boolean containsValue(Object value)
```
Specified by:

containsValue in interface PrimitiveObjectMap<V>

get
```
public V get(double key)
```
Specified by:

get in interface DoubleObjectMap<V>

getIfAbsent

public V getIfAbsent(double key,
                     Function0<? extends V> ifAbsent)

Specified by:: getIfAbsent in interface DoubleObjectMap<V>

getIfAbsentPut

public V getIfAbsentPut(double key,
                        V value)

Specified by:: getIfAbsentPut in interface MutableDoubleObjectMap<V>

getIfAbsentPut

public V getIfAbsentPut(double key,
                        Function0<? extends V> function)

Specified by:: getIfAbsentPut in interface MutableDoubleObjectMap<V>

getIfAbsentPutWith

public <P> V getIfAbsentPutWith(double key,
                                Function<? super P,? extends V> function,
                                P parameter)

Specified by:: getIfAbsentPutWith in interface MutableDoubleObjectMap<V>

getIfAbsentPutWithKey

public V getIfAbsentPutWithKey(double key,
                               DoubleToObjectFunction<? extends V> function)

Specified by:: getIfAbsentPutWithKey in interface MutableDoubleObjectMap<V>

updateValue

public V updateValue(double key,
                     Function0<? extends V> factory,
                     Function<? super V,? extends V> function)

Specified by:: updateValue in interface MutableDoubleObjectMap<V>

updateValueWith

public <P> V updateValueWith(double key,
                             Function0<? extends V> factory,
                             Function2<? super V,? super P,? extends V> function,
                             P parameter)

Specified by:: updateValueWith in interface MutableDoubleObjectMap<V>

removeKey
```
public V removeKey(double key)
```
Specified by:

removeKey in interface MutableDoubleObjectMap<V>

remove
```
public V remove(double key)
```
Specified by:

remove in interface MutableDoubleObjectMap<V>

withKeyValue

public DoubleObjectHashMap<V> withKeyValue(double key,
                                           V value)

Specified by:: withKeyValue in interface MutableDoubleObjectMap<V>

withoutKey
```
public MutableDoubleObjectMap<V> withoutKey(double key)
```
Specified by:

withoutKey in interface MutableDoubleObjectMap<V>

withoutAllKeys

public MutableDoubleObjectMap<V> withoutAllKeys(DoubleIterable keys)

Specified by:: withoutAllKeys in interface MutableDoubleObjectMap<V>

withKeysValues

public DoubleObjectHashMap<V> withKeysValues(double key1,
                                             V value1,
                                             double key2,
                                             V value2)

withKeysValues

public DoubleObjectHashMap<V> withKeysValues(double key1,
                                             V value1,
                                             double key2,
                                             V value2,
                                             double key3,
                                             V value3)

withKeysValues

public DoubleObjectHashMap<V> withKeysValues(double key1,
                                             V value1,
                                             double key2,
                                             V value2,
                                             double key3,
                                             V value3,
                                             double key4,
                                             V value4)

asUnmodifiable
```
public MutableDoubleObjectMap<V> asUnmodifiable()
```
Specified by:

asUnmodifiable in interface MutableDoubleObjectMap<V>

asSynchronized
```
public MutableDoubleObjectMap<V> asSynchronized()
```
Specified by:

asSynchronized in interface MutableDoubleObjectMap<V>

toImmutable
```
public ImmutableDoubleObjectMap<V> toImmutable()
```
Specified by:

toImmutable in interface DoubleObjectMap<V>

removeIf

public boolean removeIf(DoubleObjectPredicate<? super V> predicate)

Specified by:: removeIf in interface MutableDoubleObjectMap<V>

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:: writeExternal in interface Externalizable
Throws:: IOException

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Specified by:: readExternal in interface Externalizable
Throws:: IOException; ClassNotFoundException

keySet
```
public MutableDoubleSet keySet()
```
Specified by:

keySet in interface DoubleObjectMap<V>

trimToSize
```
public boolean trimToSize()
```
Since:

12.0

compact
```
@Deprecated
public void compact()
```
Deprecated.
since 12.0 - Use trimToSize() instead

Rehashes every element in the set into a new backing table of the smallest possible size and eliminating removed sentinels.

values
```
public Collection<V> values()
```
Specified by:

values in interface PrimitiveObjectMap<V>

keysView
```
public LazyDoubleIterable keysView()
```
Specified by:

keysView in interface DoubleObjectMap<V>

keyValuesView
```
public RichIterable<DoubleObjectPair<V>> keyValuesView()
```
Specified by:

keyValuesView in interface DoubleObjectMap<V>

flipUniqueValues
```
public MutableObjectDoubleMap<V> flipUniqueValues()
```
Specified by:

flipUniqueValues in interface DoubleObjectMap<V>

Specified by:

flipUniqueValues in interface MutableDoubleObjectMap<V>

Constructor	Description
`DoubleObjectHashMap()`
`DoubleObjectHashMap(int initialCapacity)`
`DoubleObjectHashMap(DoubleObjectMap<? extends V> map)`

Class DoubleObjectHashMap<V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.map.primitive.DoubleObjectMap

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Methods inherited from interface org.eclipse.collections.api.map.primitive.MutableDoubleObjectMap

Methods inherited from interface org.eclipse.collections.api.map.primitive.MutablePrimitiveObjectMap

Methods inherited from interface org.eclipse.collections.api.map.primitive.PrimitiveObjectMap

Methods inherited from interface org.eclipse.collections.api.RichIterable

Constructor Detail

DoubleObjectHashMap

DoubleObjectHashMap

DoubleObjectHashMap

Method Detail

newMap

newMap

newWithKeysValues

newWithKeysValues

newWithKeysValues

newWithKeysValues

equals

hashCode

toString

size

isEmpty

notEmpty

makeString

makeString

makeString

appendString

appendString

appendString

iterator

toArray

toArray

contains

containsAllIterable

containsAll

containsAllArguments

tap

each

forEachWithIndex

forEachWith

forEachValue

forEachKey

forEachKeyValue

select

reject

select

select

selectWith

selectWith

reject

reject

rejectWith

rejectWith

partition

partitionWith

selectInstancesOf

collect

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort

collectWith

collectWith

collect

collectIf

collectIf

flatCollect

flatCollect

detect

detectWith

detectOptional

detectWithOptional