com.landawn.abacus.util.ListMultimap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abacus-common Show documentation
Show all versions of abacus-common Show documentation
A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.
/*
* Copyright (C) 2017 HaiYang Li
*
* 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 com.landawn.abacus.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.Internal;
/**
*
* @author Haiyang Li
* @param the key type
* @param
* @see N#newListMultimap()
* @see N#newListMultimap(Class, Class)
* @see N#newListMultimap(Supplier, Supplier)
* @since 0.9
*/
public final class ListMultimap extends Multimap> {
ListMultimap() {
this(HashMap.class, ArrayList.class);
}
ListMultimap(int initialCapacity) {
this(N.> newHashMap(initialCapacity), ArrayList.class);
}
@SuppressWarnings("rawtypes")
ListMultimap(final Class mapType, final Class valueType) {
super(mapType, valueType);
}
ListMultimap(final Supplier>> mapSupplier, final Supplier> valueSupplier) {
super(mapSupplier, valueSupplier);
}
@Internal
@SuppressWarnings("rawtypes")
ListMultimap(final Map> valueMap, final Class valueType) {
super(valueMap, valueType2Supplier(valueType));
}
@Internal
ListMultimap(final Map> valueMap, final Supplier> valueSupplier) {
super(valueMap, valueSupplier);
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @return
*/
public static ListMultimap of(final K k1, final E v1) {
final ListMultimap map = new ListMultimap<>(1);
map.put(k1, v1);
return map;
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @param k2
* @param v2
* @return
*/
public static ListMultimap of(final K k1, final E v1, final K k2, final E v2) {
final ListMultimap map = new ListMultimap<>(2);
map.put(k1, v1);
map.put(k2, v2);
return map;
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @param k2
* @param v2
* @param k3
* @param v3
* @return
*/
public static ListMultimap of(final K k1, final E v1, final K k2, final E v2, final K k3, final E v3) {
final ListMultimap map = new ListMultimap<>(3);
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
return map;
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @param k2
* @param v2
* @param k3
* @param v3
* @param k4
* @param v4
* @return
*/
public static ListMultimap of(final K k1, final E v1, final K k2, final E v2, final K k3, final E v3, final K k4, final E v4) {
final ListMultimap map = new ListMultimap<>(4);
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
map.put(k4, v4);
return map;
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @param k2
* @param v2
* @param k3
* @param v3
* @param k4
* @param v4
* @param k5
* @param v5
* @return
*/
public static ListMultimap of(final K k1, final E v1, final K k2, final E v2, final K k3, final E v3, final K k4, final E v4, final K k5,
final E v5) {
final ListMultimap map = new ListMultimap<>(5);
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
map.put(k4, v4);
map.put(k5, v5);
return map;
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @param k2
* @param v2
* @param k3
* @param v3
* @param k4
* @param v4
* @param k5
* @param v5
* @param k6
* @param v6
* @return
*/
public static ListMultimap of(final K k1, final E v1, final K k2, final E v2, final K k3, final E v3, final K k4, final E v4, final K k5,
final E v5, final K k6, final E v6) {
final ListMultimap map = new ListMultimap<>(6);
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
map.put(k4, v4);
map.put(k5, v5);
map.put(k6, v6);
return map;
}
/**
*
* @param the key type
* @param
* @param k1
* @param v1
* @param k2
* @param v2
* @param k3
* @param v3
* @param k4
* @param v4
* @param k5
* @param v5
* @param k6
* @param v6
* @param k7
* @param v7
* @return
*/
public static ListMultimap of(final K k1, final E v1, final K k2, final E v2, final K k3, final E v3, final K k4, final E v4, final K k5,
final E v5, final K k6, final E v6, final K k7, final E v7) {
final ListMultimap map = new ListMultimap<>(7);
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
map.put(k4, v4);
map.put(k5, v5);
map.put(k6, v6);
map.put(k7, v7);
return map;
}
/**
*
* @param the key type
* @param
* @param map
* @return
*/
public static ListMultimap from(final Map map) {
final ListMultimap multimap = new ListMultimap<>(Maps.newTargetMap(map), ArrayList.class);
if (N.notNullOrEmpty(map)) {
multimap.putAll(map);
}
return multimap;
}
/**
*
* @param the key type
* @param
* @param map
* @return
*/
@Beta
public static ListMultimap fromm(final Map> map) {
final ListMultimap multimap = new ListMultimap<>(Maps.newTargetMap(map), ArrayList.class);
if (N.notNullOrEmpty(map)) {
for (Map.Entry> entry : map.entrySet()) {
multimap.putAll(entry.getKey(), entry.getValue());
}
}
return multimap;
}
/**
*
* @param
* @param the key type
* @param
* @param c
* @param keyMapper
* @return
* @throws X the x
*/
public static ListMultimap from(final Collection c,
final Throwables.Function keyMapper) throws X {
N.checkArgNotNull(keyMapper);
final ListMultimap multimap = N.newListMultimap(N.size(c));
if (N.notNullOrEmpty(c)) {
for (T e : c) {
multimap.put(keyMapper.apply(e), e);
}
}
return multimap;
}
/**
*
* @param
* @param the key type
* @param
* @param
* @param
* @param c
* @param keyMapper
* @param valueExtractor
* @return
* @throws X the x
* @throws X2 the x2
*/
public static ListMultimap from(final Collection c,
final Throwables.Function keyMapper, final Throwables.Function valueExtractor) throws X, X2 {
N.checkArgNotNull(keyMapper);
N.checkArgNotNull(valueExtractor);
final ListMultimap multimap = N.newListMultimap(N.size(c));
if (N.notNullOrEmpty(c)) {
for (T e : c) {
multimap.put(keyMapper.apply(e), valueExtractor.apply(e));
}
}
return multimap;
}
/**
*
* @param the key type
* @param
* @param map
* @return
* @see Multimap#invertFrom(Map, Supplier)
*/
public static ListMultimap invertFrom(final Map map) {
final ListMultimap multimap = new ListMultimap<>(Maps.newOrderingMap(map), ArrayList.class);
if (N.notNullOrEmpty(map)) {
for (Map.Entry entry : map.entrySet()) {
multimap.put(entry.getValue(), entry.getKey());
}
}
return multimap;
}
/**
* Flat invert from.
*
* @param the key type
* @param
* @param map
* @return
* @see Multimap#flatInvertFrom(Map, Supplier)
*/
public static ListMultimap flatInvertFrom(final Map> map) {
final ListMultimap multimap = new ListMultimap<>(Maps.newOrderingMap(map), ArrayList.class);
if (N.notNullOrEmpty(map)) {
for (Map.Entry> entry : map.entrySet()) {
final Collection c = entry.getValue();
if (N.notNullOrEmpty(c)) {
for (E e : c) {
multimap.put(e, entry.getKey());
}
}
}
}
return multimap;
}
/**
*
* @param the key type
* @param
* @param the value type
* @param map
* @return
*/
public static > ListMultimap invertFrom(final Multimap map) {
final ListMultimap multimap = new ListMultimap<>(Maps.newOrderingMap(map.valueMap), ArrayList.class);
if (N.notNullOrEmpty(map)) {
for (Map.Entry entry : map.entrySet()) {
final V c = entry.getValue();
if (N.notNullOrEmpty(c)) {
for (E e : c) {
multimap.put(e, entry.getKey());
}
}
}
}
return multimap;
}
/**
*
* @param the key type
* @param
* @param a
* @param b
* @return
*/
public static ListMultimap concat(final Map a, final Map b) {
if (a == null) {
return b == null ? N. newListMultimap() : from(b);
} else {
final ListMultimap res = from(a);
res.putAll(b);
return res;
}
}
/**
*
* @param the key type
* @param
* @param a
* @param b
* @param c
* @return
*/
public static ListMultimap concat(final Map a, final Map b,
final Map c) {
if (a == null) {
if (b == null) {
return c == null ? N. newListMultimap() : from(c);
} else {
final ListMultimap res = from(b);
res.putAll(c);
return res;
}
} else {
final ListMultimap res = from(a);
res.putAll(b);
res.putAll(c);
return res;
}
}
/**
*
* @param the key type
* @param
* @param the value type
* @param map
* @return
*/
@SuppressWarnings("rawtypes")
public static > ListMultimap wrap(final Map map) {
N.checkArgNotNull(map);
N.checkArgument(N.anyNull(map.values()), "The specified map contains null value: %s", map);
Class valueType = ArrayList.class;
for (V v : map.values()) {
if (v != null) {
valueType = v.getClass();
break;
}
}
return new ListMultimap<>((Map>) map, valueType);
}
/**
*
* @param the key type
* @param
* @param the value type
* @param map
* @param valueSupplier
* @return
*/
@SuppressWarnings("rawtypes")
public static > ListMultimap wrapp(final Map map, final Supplier valueSupplier) {
N.checkArgNotNull(map, "map");
N.checkArgNotNull(valueSupplier, "valueSupplier");
return new ListMultimap<>((Map) map, valueSupplier);
}
/**
*
* @param the key type
* @param
* @param the value type
* @param
* @param map
* @param multimapSupplier
* @return
*/
@Deprecated
public static , M extends Multimap> M from(final Map map,
final IntFunction multimapSupplier) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
*
* @param the key type
* @param
* @param the value type
* @param
* @param map
* @param multimapSupplier
* @return
*/
@Deprecated
public static , M extends Multimap> M fromm(final Map> map,
final IntFunction multimapSupplier) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
*
* @param
* @param the key type
* @param the value type
* @param
* @param
* @param c
* @param keyMapper
* @param multimapSupplier
* @return
* @throws X the x
*/
@Deprecated
public static , M extends Multimap, X extends Exception> M from(final Collection c,
final Throwables.Function keyMapper, final IntFunction multimapSupplier) throws X {
throw new UnsupportedOperationException();
}
/**
*
* @param
* @param the key type
* @param
* @param the value type
* @param
* @param
* @param
* @param c
* @param keyMapper
* @param valueExtractor
* @param multimapSupplier
* @return
* @throws X the x
* @throws X2 the x2
*/
@Deprecated
public static , M extends Multimap, X extends Exception, X2 extends Exception> M from(
final Collection c, final Throwables.Function keyMapper,
final Throwables.Function valueExtractor, final IntFunction multimapSupplier) throws X, X2 {
throw new UnsupportedOperationException();
}
/**
*
* @param the key type
* @param
* @param the value type
* @param
* @param map
* @param multimapSupplier
* @return
*/
@Deprecated
public static , M extends Multimap> M invertFrom(final Map map,
final IntFunction multimapSupplier) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
* Flat invert from.
*
* @param the key type
* @param
* @param the value type
* @param
* @param map
* @param multimapSupplier
* @return
*/
@Deprecated
public static , M extends Multimap> M flatInvertFrom(final Map> map,
final IntFunction multimapSupplier) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
*
* @param the key type
* @param
* @param the value type
* @param
* @param
* @param multimap
* @param multimapSupplier
* @return
*/
@Deprecated
public static , VV extends Collection, M extends Multimap> M invertFrom(final Multimap multimap,
final IntFunction multimapSupplier) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
*
* @param the key type
* @param
* @param the value type
* @param
* @param a
* @param b
* @param multimapSupplier
* @return
*/
@Deprecated
public static , M extends Multimap> M concat(final Map a,
final Map b, final IntFunction multimapSupplier) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
*
* @param the key type
* @param
* @param the value type
* @param
* @param a
* @param b
* @param c
* @param multimapSupplier
* @return
*/
@Deprecated
public static , M extends Multimap> M concat(final Map a,
final Map b, final Map c, final IntFunction multimapSupplier)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
*
* @param the key type
* @param
* @param the value type
* @param map
* @param valueSupplier
* @return
*/
@Deprecated
public static > Multimap wrap(final Map map, final Supplier valueSupplier)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
* Filter by key.
*
* @param
* @param filter
* @return
* @throws X the x
*/
@Override
public ListMultimap filterByKey(Throwables.Predicate filter) throws X {
final ListMultimap result = new ListMultimap<>(mapSupplier, valueSupplier);
for (Map.Entry> entry : valueMap.entrySet()) {
if (filter.test(entry.getKey())) {
result.valueMap.put(entry.getKey(), entry.getValue());
}
}
return result;
}
/**
* Filter by value.
*
* @param
* @param filter
* @return
* @throws X the x
*/
@Override
public ListMultimap filterByValue(Throwables.Predicate, X> filter) throws X {
final ListMultimap result = new ListMultimap<>(mapSupplier, valueSupplier);
for (Map.Entry> entry : valueMap.entrySet()) {
if (filter.test(entry.getValue())) {
result.valueMap.put(entry.getKey(), entry.getValue());
}
}
return result;
}
/**
*
* @param
* @param filter
* @return
* @throws X the x
*/
@Override
public ListMultimap filter(Throwables.BiPredicate, X> filter) throws X {
final ListMultimap result = new ListMultimap<>(mapSupplier, valueSupplier);
for (Map.Entry> entry : valueMap.entrySet()) {
if (filter.test(entry.getKey(), entry.getValue())) {
result.valueMap.put(entry.getKey(), entry.getValue());
}
}
return result;
}
@Override
public ListMultimap copy() {
final ListMultimap copy = new ListMultimap<>(mapSupplier, valueSupplier);
copy.putAll(this);
return copy;
}
/**
* To immutable map.
*
* @return
*/
public ImmutableMap> toImmutableMap() {
final Map> map = Maps.newOrderingMap(valueMap);
for (Map.Entry> entry : valueMap.entrySet()) {
map.put(entry.getKey(), ImmutableList.copyOf(entry.getValue()));
}
return ImmutableMap.of(map);
}
/**
* To immutable map.
*
* @param mapSupplier
* @return
*/
public ImmutableMap> toImmutableMap(final IntFunction>> mapSupplier) {
final Map> map = mapSupplier.apply(valueMap.size());
for (Map.Entry> entry : valueMap.entrySet()) {
map.put(entry.getKey(), ImmutableList.copyOf(entry.getValue()));
}
return ImmutableMap.of(map);
}
// It won't work.
// /**
// * Returns a synchronized {@code ListMultimap} which shares the same internal {@code Map} with this {@code ListMultimap}.
// * That's to say the changes in one of the returned {@code ListMultimap} and this {@code ListMultimap} will impact another one.
// *
// * @see Collections#synchronizedMap(Map)
// */
// @Override
// public ListMultimap synchronizedd() {
// return new ListMultimap<>(Collections.synchronizedMap(valueMap), concreteValueType);
// }
// public ListMultimap inversed() {
// final ListMultimap multimap = new ListMultimap(valueMap.getClass(), concreteValueType);
//
// if (N.notNullOrEmpty(valueMap)) {
// for (Map.Entry> entry : valueMap.entrySet()) {
// final List c = entry.getValue();
//
// if (N.notNullOrEmpty(c)) {
// for (E e : c) {
// multimap.put(e, entry.getKey());
// }
// }
// }
// }
//
// return multimap;
// }
}