调整集合相关工具类。

src/main/java/xyz/zhouxy/plusone/commons/collection/AbstractMapWrapper.java

@@ -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);

src/main/java/xyz/zhouxy/plusone/commons/collection/CollectionTools.java

@@ -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;
+public class CollectionTools {
-import xyz.zhouxy.plusone.commons.collection.SynchronizedTable;
-
-public class MoreCollections {
 
     // isEmpty
 
@@ -100,70 +95,7 @@ public class MoreCollections {
         }
     }
 
-    // array -> map
+    private CollectionTools() {
-
-    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() {
         throw new IllegalStateException("Utility class");
     }
 }

src/main/java/xyz/zhouxy/plusone/commons/collection/ListTools.java

@@ -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");
+    }
+}

src/main/java/xyz/zhouxy/plusone/commons/collection/MapTools.java

@@ -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");
+    }
+}

src/main/java/xyz/zhouxy/plusone/commons/collection/TableTools.java

@@ -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");
+    }
+}

src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java

@@ -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");
+    }
+}

src/main/java/xyz/zhouxy/plusone/commons/util/MoreArrays.java

@@ -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");
-    }
-}

src/main/java/xyz/zhouxy/plusone/commons/util/TreeBuilder.java

@@ -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());