调整集合相关工具类。
parent
81c5b6972a
commit
5cee71a342
|
@ -79,21 +79,6 @@ public abstract class AbstractMapWrapper<K, V, T extends AbstractMapWrapper<K, V
|
|||
return Optional.ofNullable(this.map.get(key));
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取 {@code map} 中的值。如果 {@code key} 不存在,则抛出异常。
|
||||
*
|
||||
* @param key 键
|
||||
* @return 值
|
||||
* @throws IllegalArgumentException key 不存在时抛出。
|
||||
*/
|
||||
@Nullable
|
||||
public V getOrNull(K key) {
|
||||
if (!this.map.containsKey(key)) {
|
||||
throw new IllegalArgumentException("Key does not exist");
|
||||
}
|
||||
return this.map.get(key);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public final <R> Optional<R> getAndConvert(K key) {
|
||||
return get(key).map(v -> (R) v);
|
||||
|
|
|
@ -1,6 +1,5 @@
|
|||
package xyz.zhouxy.plusone.commons.util;
|
||||
package xyz.zhouxy.plusone.commons.collection;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
|
@ -11,12 +10,8 @@ import java.util.function.Function;
|
|||
import javax.annotation.Nullable;
|
||||
|
||||
import com.google.common.base.Preconditions;
|
||||
import com.google.common.collect.Table;
|
||||
|
||||
import xyz.zhouxy.plusone.commons.collection.SafeConcurrentHashMap;
|
||||
import xyz.zhouxy.plusone.commons.collection.SynchronizedTable;
|
||||
|
||||
public class MoreCollections {
|
||||
public class CollectionTools {
|
||||
|
||||
// isEmpty
|
||||
|
||||
|
@ -100,70 +95,7 @@ public class MoreCollections {
|
|||
}
|
||||
}
|
||||
|
||||
// array -> map
|
||||
|
||||
public static <K, V> HashMap<K, V> toHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator,
|
||||
int initialCapacity) {
|
||||
HashMap<K, V> map = new HashMap<>(initialCapacity);
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> HashMap<K, V> toHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
return toHashMap(c, keyGenerator, c.length);
|
||||
}
|
||||
|
||||
public static <K, V> SafeConcurrentHashMap<K, V> toConcurrentHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator,
|
||||
int initialCapacity) {
|
||||
SafeConcurrentHashMap<K, V> map = new SafeConcurrentHashMap<>(initialCapacity);
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> SafeConcurrentHashMap<K, V> toConcurrentHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
return toConcurrentHashMap(c, keyGenerator, c.length);
|
||||
}
|
||||
|
||||
public static <K extends Comparable<? super K>, V> TreeMap<K, V> toTreeMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
TreeMap<K, V> map = new TreeMap<>();
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> TreeMap<K, V> toTreeMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator,
|
||||
Comparator<? super K> keyComparator) {
|
||||
TreeMap<K, V> map = new TreeMap<>(keyComparator);
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> void fillIntoEmptyMap(
|
||||
Map<K, ? super V> map, V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
fillIntoEmptyMap(map, Arrays.asList(c), keyGenerator);
|
||||
}
|
||||
|
||||
public static <R, C, V> Table<R, C, V> synchronizedTable(Table<R, C, V> t) {
|
||||
if (t instanceof SynchronizedTable) {
|
||||
return t;
|
||||
} else {
|
||||
return SynchronizedTable.of(t);
|
||||
}
|
||||
}
|
||||
|
||||
private MoreCollections() {
|
||||
private CollectionTools() {
|
||||
throw new IllegalStateException("Utility class");
|
||||
}
|
||||
}
|
|
@ -0,0 +1,15 @@
|
|||
package xyz.zhouxy.plusone.commons.collection;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.function.Function;
|
||||
|
||||
public class ListTools {
|
||||
|
||||
public static <T> void transformValue(List<T> list, int index, Function<T, ? extends T> func) {
|
||||
list.set(index, func.apply(list.get(index)));
|
||||
}
|
||||
|
||||
private ListTools() {
|
||||
throw new IllegalStateException("Utility class");
|
||||
}
|
||||
}
|
|
@ -0,0 +1,17 @@
|
|||
package xyz.zhouxy.plusone.commons.collection;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.Function;
|
||||
|
||||
public class MapTools {
|
||||
|
||||
public static <K, V> void transformValue(Map<K, V> map, K key, Function<V, ? extends V> func) {
|
||||
if (map.containsKey(key)) {
|
||||
map.put(key, func.apply(map.get(key)));
|
||||
}
|
||||
}
|
||||
|
||||
private MapTools() {
|
||||
throw new IllegalStateException("Utility class");
|
||||
}
|
||||
}
|
|
@ -0,0 +1,17 @@
|
|||
package xyz.zhouxy.plusone.commons.collection;
|
||||
|
||||
import com.google.common.collect.Table;
|
||||
|
||||
public class TableTools {
|
||||
|
||||
public static <R, C, V> Table<R, C, V> synchronizedTable(Table<R, C, V> t) {
|
||||
if (t instanceof SynchronizedTable) {
|
||||
return t;
|
||||
}
|
||||
return SynchronizedTable.of(t);
|
||||
}
|
||||
|
||||
private TableTools() {
|
||||
throw new IllegalStateException("Utility class");
|
||||
}
|
||||
}
|
|
@ -0,0 +1,247 @@
|
|||
/*
|
||||
* Copyright 2022-2023 the original author or authors.
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* https://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 xyz.zhouxy.plusone.commons.util;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.TreeMap;
|
||||
import java.util.function.Function;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
import com.google.common.annotations.Beta;
|
||||
|
||||
import xyz.zhouxy.plusone.commons.collection.CollectionTools;
|
||||
import xyz.zhouxy.plusone.commons.collection.SafeConcurrentHashMap;
|
||||
|
||||
@Beta
|
||||
public class ArrayTools {
|
||||
|
||||
// isNullOrEmpty
|
||||
|
||||
public static <T> boolean isNullOrEmpty(T[] arr) {
|
||||
return arr == null || arr.length == 0;
|
||||
}
|
||||
|
||||
// isNullOrEmpty - float
|
||||
public static boolean isNullOrEmpty(float[] arr) {
|
||||
return arr == null || arr.length == 0;
|
||||
}
|
||||
|
||||
// isNullOrEmpty - double
|
||||
public static boolean isNullOrEmpty(double[] arr) {
|
||||
return arr == null || arr.length == 0;
|
||||
}
|
||||
|
||||
// isNullOrEmpty - byte
|
||||
public static boolean isNullOrEmpty(byte[] arr) {
|
||||
return arr == null || arr.length == 0;
|
||||
}
|
||||
|
||||
// isNullOrEmpty - long
|
||||
public static boolean isNullOrEmpty(long[] arr) {
|
||||
return arr == null || arr.length == 0;
|
||||
}
|
||||
|
||||
// isNullOrEmpty - int
|
||||
public static boolean isNullOrEmpty(int[] arr) {
|
||||
return arr == null || arr.length == 0;
|
||||
}
|
||||
|
||||
// isNotEmpty
|
||||
|
||||
public static <T> boolean isNotEmpty(T[] arr) {
|
||||
return arr != null && arr.length > 0;
|
||||
}
|
||||
|
||||
// isNotEmpty - float
|
||||
public static boolean isNotEmpty(float[] arr) {
|
||||
return arr != null && arr.length > 0;
|
||||
}
|
||||
|
||||
// isNotEmpty - double
|
||||
public static boolean isNotEmpty(double[] arr) {
|
||||
return arr != null && arr.length > 0;
|
||||
}
|
||||
|
||||
// isNotEmpty - byte
|
||||
public static boolean isNotEmpty(byte[] arr) {
|
||||
return arr != null && arr.length > 0;
|
||||
}
|
||||
|
||||
// isNotEmpty - long
|
||||
public static boolean isNotEmpty(long[] arr) {
|
||||
return arr != null && arr.length > 0;
|
||||
}
|
||||
|
||||
// isNotEmpty - int
|
||||
public static boolean isNotEmpty(int[] arr) {
|
||||
return arr != null && arr.length > 0;
|
||||
}
|
||||
|
||||
// concat
|
||||
|
||||
public static float[] concatFloatArray(Collection<float[]> arrays) {
|
||||
int length = 0;
|
||||
for (float[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
float[] result = new float[length];
|
||||
int i = 0;
|
||||
for (float[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static double[] concatDoubleArray(Collection<double[]> arrays) {
|
||||
int length = 0;
|
||||
for (double[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
double[] result = new double[length];
|
||||
int i = 0;
|
||||
for (double[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static byte[] concatByteArray(Collection<byte[]> arrays) {
|
||||
int length = 0;
|
||||
for (byte[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
byte[] result = new byte[length];
|
||||
int i = 0;
|
||||
for (byte[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static long[] concatLongArray(Collection<long[]> arrays) {
|
||||
int length = 0;
|
||||
for (long[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
long[] result = new long[length];
|
||||
int i = 0;
|
||||
for (long[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static int[] concatIntArray(Collection<int[]> arrays) {
|
||||
int length = 0;
|
||||
for (int[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
int[] result = new int[length];
|
||||
int i = 0;
|
||||
for (int[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static <T> List<T> concatToList(@Nullable Collection<T[]> arrays) {
|
||||
if (arrays == null || arrays.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
int length = 0;
|
||||
for (T[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
final List<T> result = new ArrayList<>(length);
|
||||
for (T[] arr : arrays) {
|
||||
Collections.addAll(result, arr);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// array -> map
|
||||
|
||||
public static <K, V> HashMap<K, V> toHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator,
|
||||
int initialCapacity) {
|
||||
HashMap<K, V> map = new HashMap<>(initialCapacity);
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> HashMap<K, V> toHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
return toHashMap(c, keyGenerator, c.length);
|
||||
}
|
||||
|
||||
public static <K, V> SafeConcurrentHashMap<K, V> toConcurrentHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator,
|
||||
int initialCapacity) {
|
||||
SafeConcurrentHashMap<K, V> map = new SafeConcurrentHashMap<>(initialCapacity);
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> SafeConcurrentHashMap<K, V> toConcurrentHashMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
return toConcurrentHashMap(c, keyGenerator, c.length);
|
||||
}
|
||||
|
||||
public static <K extends Comparable<? super K>, V> TreeMap<K, V> toTreeMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
TreeMap<K, V> map = new TreeMap<>();
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> TreeMap<K, V> toTreeMap(
|
||||
V[] c,
|
||||
Function<? super V, K> keyGenerator,
|
||||
Comparator<? super K> keyComparator) {
|
||||
TreeMap<K, V> map = new TreeMap<>(keyComparator);
|
||||
fillIntoEmptyMap(map, c, keyGenerator);
|
||||
return map;
|
||||
}
|
||||
|
||||
public static <K, V> void fillIntoEmptyMap(
|
||||
Map<K, ? super V> map, V[] c,
|
||||
Function<? super V, K> keyGenerator) {
|
||||
CollectionTools.fillIntoEmptyMap(map, Arrays.asList(c), keyGenerator);
|
||||
}
|
||||
|
||||
private ArrayTools() {
|
||||
throw new IllegalStateException("Utility class");
|
||||
}
|
||||
}
|
|
@ -1,119 +0,0 @@
|
|||
/*
|
||||
* Copyright 2022-2023 the original author or authors.
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* https://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 xyz.zhouxy.plusone.commons.util;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
import com.google.common.annotations.Beta;
|
||||
|
||||
@Beta
|
||||
public class MoreArrays {
|
||||
|
||||
public static float[] concatFloatArray(Collection<float[]> arrays) {
|
||||
int length = 0;
|
||||
for (float[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
float[] result = new float[length];
|
||||
int i = 0;
|
||||
for (float[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static double[] concatDoubleArray(Collection<double[]> arrays) {
|
||||
int length = 0;
|
||||
for (double[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
double[] result = new double[length];
|
||||
int i = 0;
|
||||
for (double[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static byte[] concatByteArray(Collection<byte[]> arrays) {
|
||||
int length = 0;
|
||||
for (byte[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
byte[] result = new byte[length];
|
||||
int i = 0;
|
||||
for (byte[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static long[] concatLongArray(Collection<long[]> arrays) {
|
||||
int length = 0;
|
||||
for (long[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
long[] result = new long[length];
|
||||
int i = 0;
|
||||
for (long[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static int[] concatIntArray(Collection<int[]> arrays) {
|
||||
int length = 0;
|
||||
for (int[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
int[] result = new int[length];
|
||||
int i = 0;
|
||||
for (int[] arr : arrays) {
|
||||
System.arraycopy(arr, 0, result, i, arr.length);
|
||||
i = arr.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static <T> List<T> concatToList(@Nullable Collection<T[]> arrays) {
|
||||
if (arrays == null || arrays.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
int length = 0;
|
||||
for (T[] arr : arrays) {
|
||||
length += arr.length;
|
||||
}
|
||||
final List<T> result = new ArrayList<>(length);
|
||||
for (T[] arr : arrays) {
|
||||
Collections.addAll(result, arr);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private MoreArrays() {
|
||||
throw new IllegalStateException("Utility class");
|
||||
}
|
||||
}
|
|
@ -8,6 +8,8 @@ import java.util.function.BiConsumer;
|
|||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import xyz.zhouxy.plusone.commons.collection.CollectionTools;
|
||||
|
||||
public class TreeBuilder<T, TSubTree extends T, TIdentity> {
|
||||
private final Collection<T> nodes;
|
||||
private final Function<T, TIdentity> identityGetter;
|
||||
|
@ -23,7 +25,7 @@ public class TreeBuilder<T, TSubTree extends T, TIdentity> {
|
|||
}
|
||||
|
||||
public List<T> buildTree() {
|
||||
Map<TIdentity, T> identityNodeMap = MoreCollections.toHashMap(nodes, identityGetter);
|
||||
Map<TIdentity, T> identityNodeMap = CollectionTools.toHashMap(nodes, identityGetter);
|
||||
List<T> result = this.nodes.stream()
|
||||
.filter(node -> !this.parentIdentityGetter.apply(node).isPresent())
|
||||
.collect(Collectors.toList());
|
||||
|
|
Loading…
Reference in New Issue