io.vavr.collection.HashMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of vavr Show documentation
Show all versions of vavr Show documentation
Vavr is an object-functional library for Java 8+
/* __ __ __ __ __ ___
* \ \ / / \ \ / / __/
* \ \/ / /\ \ \/ / /
* \____/__/ \__\____/__/
*
* Copyright 2014-2019 Vavr, http://vavr.io
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.vavr.collection;
import io.vavr.Tuple;
import io.vavr.Tuple2;
import io.vavr.control.Option;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.*;
import java.util.stream.Collector;
/**
* An immutable {@code HashMap} implementation based on a
* Hash array mapped trie (HAMT).
*
* @author Ruslan Sennov, Patryk Najda, Daniel Dietrich
*/
public final class HashMap implements Map, Serializable {
private static final long serialVersionUID = 1L;
private static final HashMap EMPTY = new HashMap<>(HashArrayMappedTrie.empty());
private final HashArrayMappedTrie trie;
private HashMap(HashArrayMappedTrie trie) {
this.trie = trie;
}
/**
* Returns a {@link java.util.stream.Collector} which may be used in conjunction with
* {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link HashMap}.
*
* @param The key type
* @param The value type
* @return A {@link HashMap} Collector.
*/
public static Collector, ArrayList>, HashMap> collector() {
final Supplier>> supplier = ArrayList::new;
final BiConsumer>, Tuple2> accumulator = ArrayList::add;
final BinaryOperator>> combiner = (left, right) -> {
left.addAll(right);
return left;
};
final Function>, HashMap> finisher = HashMap::ofEntries;
return Collector.of(supplier, accumulator, combiner, finisher);
}
/**
* Returns a {@link java.util.stream.Collector} which may be used in conjunction with
* {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link HashMap}.
*
* @param keyMapper The key mapper
* @param The key type
* @param The value type
* @param Initial {@link java.util.stream.Stream} elements type
* @return A {@link HashMap} Collector.
*/
public static Collector, HashMap> collector(Function keyMapper) {
Objects.requireNonNull(keyMapper, "keyMapper is null");
return HashMap.collector(keyMapper, v -> v);
}
/**
* Returns a {@link java.util.stream.Collector} which may be used in conjunction with
* {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link HashMap}.
*
* @param keyMapper The key mapper
* @param valueMapper The value mapper
* @param The key type
* @param The value type
* @param Initial {@link java.util.stream.Stream} elements type
* @return A {@link HashMap} Collector.
*/
public static Collector, HashMap> collector(
Function keyMapper, Function valueMapper) {
Objects.requireNonNull(keyMapper, "keyMapper is null");
Objects.requireNonNull(valueMapper, "valueMapper is null");
final Supplier> supplier = ArrayList::new;
final BiConsumer, T> accumulator = ArrayList::add;
final BinaryOperator> combiner = (left, right) -> {
left.addAll(right);
return left;
};
final Function, HashMap> finisher = arr -> HashMap.ofEntries(Iterator.ofAll(arr)
.map(t -> Tuple.of(keyMapper.apply(t), valueMapper.apply(t))));
return Collector.of(supplier, accumulator, combiner, finisher);
}
@SuppressWarnings("unchecked")
public static HashMap empty() {
return (HashMap) EMPTY;
}
/**
* Narrows a widened {@code HashMap} to {@code HashMap}
* by performing a type-safe cast. This is eligible because immutable/read-only
* collections are covariant.
*
* @param hashMap A {@code HashMap}.
* @param Key type
* @param Value type
* @return the given {@code hashMap} instance as narrowed type {@code HashMap}.
*/
@SuppressWarnings("unchecked")
public static HashMap narrow(HashMap hashMap) {
return (HashMap) hashMap;
}
/**
* Returns a singleton {@code HashMap}, i.e. a {@code HashMap} of one element.
*
* @param entry A map entry.
* @param The key type
* @param The value type
* @return A new Map containing the given entry
*/
public static HashMap of(Tuple2 entry) {
return new HashMap<>(HashArrayMappedTrie. empty().put(entry._1, entry._2));
}
/**
* Returns a {@code HashMap}, from a source java.util.Map.
*
* @param map A map
* @param The key type
* @param The value type
* @return A new Map containing the given map
*/
public static HashMap ofAll(java.util.Map map) {
Objects.requireNonNull(map, "map is null");
HashArrayMappedTrie tree = HashArrayMappedTrie.empty();
for (java.util.Map.Entry entry : map.entrySet()) {
tree = tree.put(entry.getKey(), entry.getValue());
}
return wrap(tree);
}
/**
* Returns a {@code HashMap}, from entries mapped from stream.
*
* @param stream the source stream
* @param keyMapper the key mapper
* @param valueMapper the value mapper
* @param The stream element type
* @param The key type
* @param The value type
* @return A new Map
*/
public static HashMap ofAll(java.util.stream.Stream stream,
Function keyMapper,
Function valueMapper) {
return Maps.ofStream(empty(), stream, keyMapper, valueMapper);
}
/**
* Returns a {@code HashMap}, from entries mapped from stream.
*
* @param stream the source stream
* @param entryMapper the entry mapper
* @param The stream element type
* @param The key type
* @param The value type
* @return A new Map
*/
public static HashMap ofAll(java.util.stream.Stream stream,
Function> entryMapper) {
return Maps.ofStream(empty(), stream, entryMapper);
}
/**
* Returns a singleton {@code HashMap}, i.e. a {@code HashMap} of one element.
*
* @param key A singleton map key.
* @param value A singleton map value.
* @param The key type
* @param The value type
* @return A new Map containing the given entry
*/
public static HashMap of(K key, V value) {
return new HashMap<>(HashArrayMappedTrie. empty().put(key, value));
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2) {
return of(k1, v1).put(k2, v2);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3) {
return of(k1, v1, k2, v2).put(k3, v3);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param The key type
* @param The value type
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
return of(k1, v1, k2, v2, k3, v3).put(k4, v4);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @param k5 a key for the map
* @param v5 the value for k5
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
return of(k1, v1, k2, v2, k3, v3, k4, v4).put(k5, v5);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @param k5 a key for the map
* @param v5 the value for k5
* @param k6 a key for the map
* @param v6 the value for k6
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
return of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5).put(k6, v6);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @param k5 a key for the map
* @param v5 the value for k5
* @param k6 a key for the map
* @param v6 the value for k6
* @param k7 a key for the map
* @param v7 the value for k7
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
return of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6).put(k7, v7);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @param k5 a key for the map
* @param v5 the value for k5
* @param k6 a key for the map
* @param v6 the value for k6
* @param k7 a key for the map
* @param v7 the value for k7
* @param k8 a key for the map
* @param v8 the value for k8
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
return of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7).put(k8, v8);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @param k5 a key for the map
* @param v5 the value for k5
* @param k6 a key for the map
* @param v6 the value for k6
* @param k7 a key for the map
* @param v7 the value for k7
* @param k8 a key for the map
* @param v8 the value for k8
* @param k9 a key for the map
* @param v9 the value for k9
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
return of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8).put(k9, v9);
}
/**
* Creates a HashMap of the given list of key-value pairs.
*
* @param k1 a key for the map
* @param v1 the value for k1
* @param k2 a key for the map
* @param v2 the value for k2
* @param k3 a key for the map
* @param v3 the value for k3
* @param k4 a key for the map
* @param v4 the value for k4
* @param k5 a key for the map
* @param v5 the value for k5
* @param k6 a key for the map
* @param v6 the value for k6
* @param k7 a key for the map
* @param v7 the value for k7
* @param k8 a key for the map
* @param v8 the value for k8
* @param k9 a key for the map
* @param v9 the value for k9
* @param k10 a key for the map
* @param v10 the value for k10
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
public static HashMap of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
return of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9).put(k10, v10);
}
/**
* Returns an HashMap containing {@code n} values of a given Function {@code f}
* over a range of integer values from 0 to {@code n - 1}.
*
* @param The key type
* @param The value type
* @param n The number of elements in the HashMap
* @param f The Function computing element values
* @return An HashMap consisting of elements {@code f(0),f(1), ..., f(n - 1)}
* @throws NullPointerException if {@code f} is null
*/
@SuppressWarnings("unchecked")
public static HashMap tabulate(int n, Function> f) {
Objects.requireNonNull(f, "f is null");
return ofEntries(Collections.tabulate(n, (Function>) f));
}
/**
* Returns a HashMap containing tuples returned by {@code n} calls to a given Supplier {@code s}.
*
* @param The key type
* @param The value type
* @param n The number of elements in the HashMap
* @param s The Supplier computing element values
* @return An HashMap of size {@code n}, where each element contains the result supplied by {@code s}.
* @throws NullPointerException if {@code s} is null
*/
@SuppressWarnings("unchecked")
public static HashMap fill(int n, Supplier> s) {
Objects.requireNonNull(s, "s is null");
return ofEntries(Collections.fill(n, (Supplier>) s));
}
/**
* Creates a HashMap of the given entries.
*
* @param entries Map entries
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
@SafeVarargs
public static HashMap ofEntries(java.util.Map.Entry... entries) {
Objects.requireNonNull(entries, "entries is null");
HashArrayMappedTrie trie = HashArrayMappedTrie.empty();
for (java.util.Map.Entry entry : entries) {
trie = trie.put(entry.getKey(), entry.getValue());
}
return wrap(trie);
}
/**
* Creates a HashMap of the given entries.
*
* @param entries Map entries
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
@SafeVarargs
public static HashMap ofEntries(Tuple2... entries) {
Objects.requireNonNull(entries, "entries is null");
HashArrayMappedTrie trie = HashArrayMappedTrie.empty();
for (Tuple2 entry : entries) {
trie = trie.put(entry._1, entry._2);
}
return wrap(trie);
}
/**
* Creates a HashMap of the given entries.
*
* @param entries Map entries
* @param The key type
* @param The value type
* @return A new Map containing the given entries
*/
@SuppressWarnings("unchecked")
public static HashMap ofEntries(Iterable> entries) {
Objects.requireNonNull(entries, "entries is null");
if (entries instanceof HashMap) {
return (HashMap) entries;
} else {
HashArrayMappedTrie trie = HashArrayMappedTrie.empty();
for (Tuple2 entry : entries) {
trie = trie.put(entry._1, entry._2);
}
return trie.isEmpty() ? empty() : wrap(trie);
}
}
@Override
public HashMap bimap(Function keyMapper, Function valueMapper) {
Objects.requireNonNull(keyMapper, "keyMapper is null");
Objects.requireNonNull(valueMapper, "valueMapper is null");
final Iterator> entries = iterator().map(entry -> Tuple.of(keyMapper.apply(entry._1), valueMapper.apply(entry._2)));
return HashMap.ofEntries(entries);
}
@Override
public Tuple2> computeIfAbsent(K key, Function mappingFunction) {
return Maps.computeIfAbsent(this, key, mappingFunction);
}
@Override
public Tuple2, HashMap> computeIfPresent(K key, BiFunction remappingFunction) {
return Maps.computeIfPresent(this, key, remappingFunction);
}
@Override
public boolean containsKey(K key) {
return trie.containsKey(key);
}
@Override
public HashMap distinct() {
return Maps.distinct(this);
}
@Override
public HashMap distinctBy(Comparator> comparator) {
return Maps.distinctBy(this, this::createFromEntries, comparator);
}
@Override
public HashMap distinctBy(Function, ? extends U> keyExtractor) {
return Maps.distinctBy(this, this::createFromEntries, keyExtractor);
}
@Override
public HashMap drop(int n) {
return Maps.drop(this, this::createFromEntries, HashMap::empty, n);
}
@Override
public HashMap dropRight(int n) {
return Maps.dropRight(this, this::createFromEntries, HashMap::empty, n);
}
@Override
public HashMap dropUntil(Predicate> predicate) {
return Maps.dropUntil(this, this::createFromEntries, predicate);
}
@Override
public HashMap dropWhile(Predicate> predicate) {
return Maps.dropWhile(this, this::createFromEntries, predicate);
}
@Override
public HashMap filter(BiPredicate predicate) {
return Maps.filter(this, this::createFromEntries, predicate);
}
@Override
public HashMap reject(BiPredicate predicate) {
return Maps.reject(this, this::createFromEntries, predicate);
}
@Override
public HashMap filter(Predicate> predicate) {
return Maps.filter(this, this::createFromEntries, predicate);
}
@Override
public HashMap reject(Predicate> predicate) {
return Maps.reject(this, this::createFromEntries, predicate);
}
@Override
public HashMap filterKeys(Predicate predicate) {
return Maps.filterKeys(this, this::createFromEntries, predicate);
}
@Override
public HashMap rejectKeys(Predicate predicate) {
return Maps.rejectKeys(this, this::createFromEntries, predicate);
}
@Override
public HashMap filterValues(Predicate predicate) {
return Maps.filterValues(this, this::createFromEntries, predicate);
}
@Override
public HashMap rejectValues(Predicate predicate) {
return Maps.rejectValues(this, this::createFromEntries, predicate);
}
@Override
public HashMap flatMap(BiFunction>> mapper) {
Objects.requireNonNull(mapper, "mapper is null");
return foldLeft(HashMap. empty(), (acc, entry) -> {
for (Tuple2 mappedEntry : mapper.apply(entry._1, entry._2)) {
acc = acc.put(mappedEntry);
}
return acc;
});
}
@Override
public Option get(K key) {
return trie.get(key);
}
@Override
public V getOrElse(K key, V defaultValue) {
return trie.getOrElse(key, defaultValue);
}
@Override
public Map> groupBy(Function, ? extends C> classifier) {
return Maps.groupBy(this, this::createFromEntries, classifier);
}
@Override
public Iterator> grouped(int size) {
return Maps.grouped(this, this::createFromEntries, size);
}
@Override
public Tuple2 head() {
if (isEmpty()) {
throw new NoSuchElementException("head of empty HashMap");
} else {
return iterator().next();
}
}
@Override
public HashMap init() {
if (trie.isEmpty()) {
throw new UnsupportedOperationException("init of empty HashMap");
} else {
return remove(last()._1);
}
}
@Override
public Option> initOption() {
return Maps.initOption(this);
}
/**
* A {@code HashMap} is computed synchronously.
*
* @return false
*/
@Override
public boolean isAsync() {
return false;
}
@Override
public boolean isEmpty() {
return trie.isEmpty();
}
/**
* A {@code HashMap} is computed eagerly.
*
* @return false
*/
@Override
public boolean isLazy() {
return false;
}
@Override
public Iterator> iterator() {
return trie.iterator();
}
@Override
public Set keySet() {
return HashSet.ofAll(iterator().map(Tuple2::_1));
}
@Override
public Iterator keysIterator() {
return trie.keysIterator();
}
@Override
public Tuple2 last() {
return Collections.last(this);
}
@Override
public HashMap map(BiFunction> mapper) {
Objects.requireNonNull(mapper, "mapper is null");
return foldLeft(HashMap.empty(), (acc, entry) -> acc.put(entry.map(mapper)));
}
@Override
public HashMap mapKeys(Function keyMapper) {
Objects.requireNonNull(keyMapper, "keyMapper is null");
return map((k, v) -> Tuple.of(keyMapper.apply(k), v));
}
@Override
public HashMap mapKeys(Function keyMapper, BiFunction valueMerge) {
return Collections.mapKeys(this, HashMap.empty(), keyMapper, valueMerge);
}
@Override
public HashMap mapValues(Function valueMapper) {
Objects.requireNonNull(valueMapper, "valueMapper is null");
return map((k, v) -> Tuple.of(k, valueMapper.apply(v)));
}
@Override
public HashMap merge(Map that) {
return Maps.merge(this, this::createFromEntries, that);
}
@Override
public HashMap merge(Map that,
BiFunction collisionResolution) {
return Maps.merge(this, this::createFromEntries, that, collisionResolution);
}
@Override
public HashMap orElse(Iterable> other) {
return isEmpty() ? ofEntries(other) : this;
}
@Override
public HashMap orElse(Supplier>> supplier) {
return isEmpty() ? ofEntries(supplier.get()) : this;
}
@Override
public Tuple2, HashMap> partition(Predicate> predicate) {
return Maps.partition(this, this::createFromEntries, predicate);
}
@Override
public HashMap peek(Consumer> action) {
return Maps.peek(this, action);
}
@Override
public HashMap put(K key, U value, BiFunction merge) {
return Maps.put(this, key, value, merge);
}
@Override
public HashMap put(K key, V value) {
return new HashMap<>(trie.put(key, value));
}
@Override
public HashMap put(Tuple2 entry) {
return Maps.put(this, entry);
}
@Override
public HashMap put(Tuple2 entry,
BiFunction merge) {
return Maps.put(this, entry, merge);
}
@Override
public HashMap remove(K key) {
final HashArrayMappedTrie result = trie.remove(key);
return result.size() == trie.size() ? this : wrap(result);
}
@Override
@Deprecated
public HashMap removeAll(BiPredicate predicate) {
Objects.requireNonNull(predicate, "predicate is null");
return reject(predicate);
}
@Override
public HashMap removeAll(Iterable keys) {
Objects.requireNonNull(keys, "keys is null");
HashArrayMappedTrie result = trie;
for (K key : keys) {
result = result.remove(key);
}
if (result.isEmpty()) {
return empty();
} else if (result.size() == trie.size()) {
return this;
} else {
return wrap(result);
}
}
@Override
@Deprecated
public HashMap removeKeys(Predicate predicate) {
Objects.requireNonNull(predicate, "predicate is null");
return rejectKeys(predicate);
}
@Override
@Deprecated
public HashMap removeValues(Predicate predicate) {
Objects.requireNonNull(predicate, "predicate is null");
return rejectValues(predicate);
}
@Override
public HashMap replace(Tuple2 currentElement, Tuple2 newElement) {
return Maps.replace(this, currentElement, newElement);
}
@Override
public HashMap replaceAll(Tuple2 currentElement, Tuple2 newElement) {
return Maps.replaceAll(this, currentElement, newElement);
}
@Override
public HashMap replaceValue(K key, V value) {
return Maps.replaceValue(this, key, value);
}
@Override
public HashMap replace(K key, V oldValue, V newValue) {
return Maps.replace(this, key, oldValue, newValue);
}
@Override
public HashMap replaceAll(BiFunction function) {
return Maps.replaceAll(this, function);
}
@Override
public HashMap retainAll(Iterable> elements) {
Objects.requireNonNull(elements, "elements is null");
HashArrayMappedTrie tree = HashArrayMappedTrie.empty();
for (Tuple2 entry : elements) {
if (contains(entry)) {
tree = tree.put(entry._1, entry._2);
}
}
return wrap(tree);
}
@Override
public HashMap scan(
Tuple2 zero,
BiFunction, ? super Tuple2, ? extends Tuple2> operation) {
return Maps.scan(this, zero, operation, this::createFromEntries);
}
@Override
public int size() {
return trie.size();
}
@Override
public Iterator> slideBy(Function, ?> classifier) {
return Maps.slideBy(this, this::createFromEntries, classifier);
}
@Override
public Iterator> sliding(int size) {
return Maps.sliding(this, this::createFromEntries, size);
}
@Override
public Iterator> sliding(int size, int step) {
return Maps.sliding(this, this::createFromEntries, size, step);
}
@Override
public Tuple2, HashMap> span(Predicate> predicate) {
return Maps.span(this, this::createFromEntries, predicate);
}
@Override
public HashMap tail() {
if (trie.isEmpty()) {
throw new UnsupportedOperationException("tail of empty HashMap");
} else {
return remove(head()._1);
}
}
@Override
public Option> tailOption() {
return Maps.tailOption(this);
}
@Override
public HashMap take(int n) {
return Maps.take(this, this::createFromEntries, n);
}
@Override
public HashMap takeRight(int n) {
return Maps.takeRight(this, this::createFromEntries, n);
}
@Override
public HashMap takeUntil(Predicate> predicate) {
return Maps.takeUntil(this, this::createFromEntries, predicate);
}
@Override
public HashMap takeWhile(Predicate> predicate) {
return Maps.takeWhile(this, this::createFromEntries, predicate);
}
@Override
public java.util.HashMap toJavaMap() {
return toJavaMap(java.util.HashMap::new, t -> t);
}
@Override
public Stream values() {
return trie.valuesIterator().toStream();
}
@Override
public Iterator valuesIterator() {
return trie.valuesIterator();
}
@Override
public boolean equals(Object o) {
return Collections.equals(this, o);
}
@Override
public int hashCode() {
return Collections.hashUnordered(this);
}
private Object readResolve() {
return isEmpty() ? EMPTY : this;
}
@Override
public String stringPrefix() {
return "HashMap";
}
@Override
public String toString() {
return mkString(stringPrefix() + "(", ", ", ")");
}
private static HashMap wrap(HashArrayMappedTrie trie) {
return trie.isEmpty() ? empty() : new HashMap<>(trie);
}
// We need this method to narrow the argument of `ofEntries`.
// If this method is static with type args , the jdk fails to infer types at the call site.
private HashMap createFromEntries(Iterable> tuples) {
return HashMap.ofEntries(tuples);
}
}