From 65f0bb062c1bad3134ec45cefb3c28a5fcda1c0e Mon Sep 17 00:00:00 2001 From: ZhouXY108 Date: Wed, 4 Dec 2024 01:14:20 +0800 Subject: [PATCH] =?UTF-8?q?ArrayTools=EF=BC=9A=E4=BF=AE=E5=A4=8D=20concat?= =?UTF-8?q?=20=E6=96=B9=E6=B3=95=E7=9A=84=E5=8F=82=E6=95=B0=20arrays=20?= =?UTF-8?q?=E4=B8=AD=E5=AD=98=E5=9C=A8=20null=EF=BC=8C=E4=BB=8E=E8=80=8C?= =?UTF-8?q?=E6=8A=A5=E7=A9=BA=E6=8C=87=E9=92=88=E7=9A=84=E9=97=AE=E9=A2=98?= =?UTF-8?q?=EF=BC=9B=E8=A1=A5=E5=85=85=E5=8D=95=E5=85=83=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../plusone/commons/util/ArrayTools.java | 145 ++++--- .../plusone/commons/util/ArrayToolsTests.java | 400 +++++++++++++++++- 2 files changed, 485 insertions(+), 60 deletions(-) diff --git a/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java b/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java index 3987256..d547ade 100644 --- a/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java +++ b/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java @@ -23,10 +23,21 @@ import java.util.Collections; import java.util.List; import java.util.Objects; import java.util.function.Predicate; +import java.util.stream.Collectors; import javax.annotation.Nonnull; import javax.annotation.Nullable; +/** + * ArrayTools + * + *

+ * 数组工具类 + *

+ * + * @author ZhouXY + * @since 0.1.0 + */ public class ArrayTools { // #region - empty arrays @@ -267,14 +278,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static char[] concatCharArray(@Nullable Collection arrays) { + public static char[] concatCharArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new char[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final char[] result = new char[length]; int i = 0; - for (char[] arr : arrays) { + for (char[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -287,14 +302,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static byte[] concatByteArray(@Nullable Collection arrays) { + public static byte[] concatByteArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new byte[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final byte[] result = new byte[length]; int i = 0; - for (byte[] arr : arrays) { + for (byte[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -307,14 +326,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static short[] concatShortArray(@Nullable Collection arrays) { + public static short[] concatShortArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new short[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final short[] result = new short[length]; int i = 0; - for (short[] arr : arrays) { + for (short[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -327,14 +350,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static int[] concatIntArray(@Nullable Collection arrays) { + public static int[] concatIntArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new int[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final int[] result = new int[length]; int i = 0; - for (int[] arr : arrays) { + for (int[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -347,14 +374,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static long[] concatLongArray(@Nullable Collection arrays) { + public static long[] concatLongArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new long[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final long[] result = new long[length]; int i = 0; - for (long[] arr : arrays) { + for (long[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -367,14 +398,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static float[] concatFloatArray(@Nullable Collection arrays) { + public static float[] concatFloatArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new float[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final float[] result = new float[length]; int i = 0; - for (float[] arr : arrays) { + for (float[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -387,14 +422,18 @@ public class ArrayTools { * @param arrays 数组集合，可以为 {@code null} * @return 拼接后的数组 */ - public static double[] concatDoubleArray(@Nullable Collection arrays) { + public static double[] concatDoubleArray(@Nullable final Collection arrays) { if (arrays == null || arrays.isEmpty()) { return new double[0]; } - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final double[] result = new double[length]; int i = 0; - for (double[] arr : arrays) { + for (double[] arr : arraysToConcat) { System.arraycopy(arr, 0, result, i, arr.length); i += arr.length; } @@ -408,17 +447,21 @@ public class ArrayTools { * @param 泛型参数，表示数组的元素类型 * @return 返回连接后的列表，如果输入的集合为空或包含空数组，则返回空列表 */ - public static List concatToList(@Nullable Collection arrays) { + public static List concatToList(@Nullable final Collection arrays) { // 如果输入的集合是否为空，则直接返回一个空列表 if (arrays == null || arrays.isEmpty()) { return Collections.emptyList(); } + final Collection arraysToConcat = arrays + .stream() + .filter(Objects::nonNull) + .collect(Collectors.toList()); // 计算所有数组的总长度，用于初始化列表的容量 - final int length = arrays.stream().mapToInt(a -> a.length).sum(); + final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum(); final List result = new ArrayList<>(length); - for (T[] arr : arrays) { + for (T[] arr : arraysToConcat) { Collections.addAll(result, arr); } @@ -825,7 +868,7 @@ public class ArrayTools { // #region - indexOf - public static int indexOf(T[] arr, Predicate predicate) { // TODO 单元测试 + public static int indexOf(T[] arr, Predicate predicate) { AssertTools.checkNotNull(predicate); if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; @@ -838,11 +881,11 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(T[] arr, T obj) { // TODO 单元测试 + public static int indexOf(T[] arr, T obj) { return indexOf(arr, item -> Objects.equals(item, obj)); } - public static int indexOf(char[] arr, char value) { // TODO 单元测试 + public static int indexOf(char[] arr, char value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -854,7 +897,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(byte[] arr, byte value) { // TODO 单元测试 + public static int indexOf(byte[] arr, byte value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -866,7 +909,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(short[] arr, short value) { // TODO 单元测试 + public static int indexOf(short[] arr, short value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -878,7 +921,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(int[] arr, int value) { // TODO 单元测试 + public static int indexOf(int[] arr, int value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -890,7 +933,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(long[] arr, long value) { // TODO 单元测试 + public static int indexOf(long[] arr, long value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -902,7 +945,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(float[] arr, float value) { // TODO 单元测试 + public static int indexOf(float[] arr, float value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -914,7 +957,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int indexOf(double[] arr, double value) { // TODO 单元测试 + public static int indexOf(double[] arr, double value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -930,7 +973,7 @@ public class ArrayTools { // #region - lastIndexOf - public static int lastIndexOf(T[] arr, @Nonnull Predicate predicate) { // TODO 单元测试 + public static int lastIndexOf(T[] arr, @Nonnull Predicate predicate) { AssertTools.checkNotNull(predicate); if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; @@ -943,11 +986,11 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(T[] arr, T obj) { // TODO 单元测试 + public static int lastIndexOf(T[] arr, T obj) { return lastIndexOf(arr, item -> Objects.equals(item, obj)); } - public static int lastIndexOf(char[] arr, char value) { // TODO 单元测试 + public static int lastIndexOf(char[] arr, char value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -959,7 +1002,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(byte[] arr, byte value) { // TODO 单元测试 + public static int lastIndexOf(byte[] arr, byte value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -971,7 +1014,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(short[] arr, short value) { // TODO 单元测试 + public static int lastIndexOf(short[] arr, short value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -983,7 +1026,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(int[] arr, int value) { // TODO 单元测试 + public static int lastIndexOf(int[] arr, int value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -995,7 +1038,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(long[] arr, long value) { // TODO 单元测试 + public static int lastIndexOf(long[] arr, long value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -1007,7 +1050,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(float[] arr, float value) { // TODO 单元测试 + public static int lastIndexOf(float[] arr, float value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -1019,7 +1062,7 @@ public class ArrayTools { return NOT_FOUND_INDEX; } - public static int lastIndexOf(double[] arr, double value) { // TODO 单元测试 + public static int lastIndexOf(double[] arr, double value) { if (isNullOrEmpty(arr)) { return NOT_FOUND_INDEX; } @@ -1035,39 +1078,39 @@ public class ArrayTools { // #region - contains - public static boolean contains(T[] arr, T obj) { // TODO 单元测试 + public static boolean contains(T[] arr, T obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(char[] arr, char obj) { // TODO 单元测试 + public static boolean contains(char[] arr, char obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(byte[] arr, byte obj) { // TODO 单元测试 + public static boolean contains(byte[] arr, byte obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(short[] arr, short obj) { // TODO 单元测试 + public static boolean contains(short[] arr, short obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(int[] arr, int obj) { // TODO 单元测试 + public static boolean contains(int[] arr, int obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(long[] arr, long obj) { // TODO 单元测试 + public static boolean contains(long[] arr, long obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(float[] arr, float obj) { // TODO 单元测试 + public static boolean contains(float[] arr, float obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean contains(double[] arr, double obj) { // TODO 单元测试 + public static boolean contains(double[] arr, double obj) { return indexOf(arr, obj) > NOT_FOUND_INDEX; } - public static boolean containsValue(BigDecimal[] arr, BigDecimal obj) { // TODO 单元测试 + public static boolean containsValue(BigDecimal[] arr, BigDecimal obj) { return indexOf(arr, item -> BigDecimals.equalsValue(item, obj)) > NOT_FOUND_INDEX; } diff --git a/src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java b/src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java index 6b23fb2..ceafaf1 100644 --- a/src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java +++ b/src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java @@ -16,21 +16,403 @@ package xyz.zhouxy.plusone.commons.util; +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.jupiter.api.Test; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; -@SuppressWarnings("all") +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.function.Executable; + +@SuppressWarnings("null") public class ArrayToolsTests { + + // TODO 【优化】 检查、完善测试用例 + + //#region null or empty + @Test - void testIsAllNotNull() { - assertTrue(ArrayTools.isAllElementsNotNull(new Object[] { 1L, 2, 3.0, "Java" })); - assertFalse(ArrayTools.isAllElementsNotNull(new Object[] { 1L, 2, 3.0, "Java", null })); - assertFalse(ArrayTools.isAllElementsNotNull(new Object[] { null, 1L, 2, 3.0, "Java" })); - assertTrue(ArrayTools.isAllElementsNotNull(new Object[] {})); - assertThrows(IllegalArgumentException.class, - () -> ArrayTools.isAllElementsNotNull(null)); + void isNullOrEmpty_NullArray_ReturnsTrue() { + assertAll( + () -> assertTrue(ArrayTools.isNullOrEmpty((String[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((Integer[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((char[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((byte[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((short[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((int[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((long[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((float[]) null)), + () -> assertTrue(ArrayTools.isNullOrEmpty((double[]) null))); } + + @Test + void isNullOrEmpty_EmptyArray_ReturnsTrue() { + assertAll( + () -> assertTrue(ArrayTools.isNullOrEmpty(new String[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new Integer[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new char[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new byte[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new short[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new int[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new long[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new float[] {})), + () -> assertTrue(ArrayTools.isNullOrEmpty(new double[] {}))); + } + + @Test + void isNullOrEmpty_NonEmptyArray_ReturnsFalse() { + assertAll( + () -> assertFalse(ArrayTools.isNullOrEmpty(new String[] { "a" })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new Integer[] { 1 })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new char[] { 'a' })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new byte[] { 1 })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new short[] { 1 })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new int[] { 1 })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new long[] { 1 })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new float[] { 1 })), + () -> assertFalse(ArrayTools.isNullOrEmpty(new double[] { 1 }))); + } + + @Test + void isNotEmpty_NullArray_ReturnsFalse() { + assertAll( + () -> assertFalse(ArrayTools.isNotEmpty((String[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((Integer[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((char[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((byte[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((short[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((int[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((long[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((float[]) null)), + () -> assertFalse(ArrayTools.isNotEmpty((double[]) null))); + } + + @Test + void isNotEmpty_EmptyArray_ReturnsFalse() { + assertAll( + () -> assertFalse(ArrayTools.isNotEmpty(new String[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new Integer[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new char[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new byte[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new short[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new int[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new long[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new float[] {})), + () -> assertFalse(ArrayTools.isNotEmpty(new double[] {}))); + } + + @Test + void isNotEmpty_NonEmptyArray_ReturnsTrue() { + assertAll( + () -> assertTrue(ArrayTools.isNotEmpty(new String[] { "a" })), + () -> assertTrue(ArrayTools.isNotEmpty(new Integer[] { 1 })), + () -> assertTrue(ArrayTools.isNotEmpty(new char[] { 'a' })), + () -> assertTrue(ArrayTools.isNotEmpty(new byte[] { 1 })), + () -> assertTrue(ArrayTools.isNotEmpty(new short[] { 1 })), + () -> assertTrue(ArrayTools.isNotEmpty(new int[] { 1 })), + () -> assertTrue(ArrayTools.isNotEmpty(new long[] { 1 })), + () -> assertTrue(ArrayTools.isNotEmpty(new float[] { 1 })), + () -> assertTrue(ArrayTools.isNotEmpty(new double[] { 1 }))); + } + + @Test + void isAllElementsNotNull_NullArray_ThrowsException() { + assertThrows(IllegalArgumentException.class, () -> ArrayTools.isAllElementsNotNull((String[]) null)); + assertThrows(IllegalArgumentException.class, () -> ArrayTools.isAllElementsNotNull((Integer[]) null)); + } + + @Test + void isAllElementsNotNull_EmptyArray_ReturnsTrue() { + assertTrue(ArrayTools.isAllElementsNotNull(new String[] {})); + assertTrue(ArrayTools.isAllElementsNotNull(new Integer[] {})); + } + + @Test + void isAllElementsNotNull_ArrayWithNullElement_ReturnsFalse() { + assertFalse(ArrayTools.isAllElementsNotNull(new String[] { "a", null })); + assertFalse(ArrayTools.isAllElementsNotNull(new Integer[] { 1, null })); + } + + @Test + void isAllElementsNotNull_ArrayWithoutNullElements_ReturnsTrue() { + assertTrue(ArrayTools.isAllElementsNotNull(new String[] { "a", "b" })); + assertTrue(ArrayTools.isAllElementsNotNull(new Integer[] { 1, 2 })); + } + + // #endregion + + // #region - concat + + private static List charArrays; + private static List byteArrays; + private static List shortArrays; + private static List intArrays; + private static List longArrays; + private static List floatArrays; + private static List doubleArrays; + + @BeforeAll + public static void setUp() { + charArrays = new ArrayList<>(); + charArrays.add(new char[] { 'a', 'b' }); + charArrays.add(new char[] { 'c', 'd', 'e' }); + charArrays.add(null); + + byteArrays = new ArrayList<>(); + byteArrays.add(new byte[] { 1, 2 }); + byteArrays.add(new byte[] { 3, 4, 5 }); + byteArrays.add(null); + + shortArrays = new ArrayList<>(); + shortArrays.add(new short[] { 10, 20 }); + shortArrays.add(new short[] { 30, 40, 50 }); + shortArrays.add(null); + + intArrays = new ArrayList<>(); + intArrays.add(new int[] { 100, 200 }); + intArrays.add(new int[] { 300, 400, 500 }); + intArrays.add(null); + + longArrays = new ArrayList<>(); + longArrays.add(new long[] { 1000L, 2000L }); + longArrays.add(new long[] { 3000L, 4000L, 5000L }); + longArrays.add(null); + + floatArrays = new ArrayList<>(); + floatArrays.add(new float[] { 1000.1f, 2000.2f }); + floatArrays.add(new float[] { 3000.3f, 4000.4f, 5000.5f }); + floatArrays.add(null); + + doubleArrays = new ArrayList<>(); + doubleArrays.add(new double[] { 1000.1d, 2000.2d }); + doubleArrays.add(new double[] { 3000.3d, 4000.4d, 5000.5d }); + doubleArrays.add(null); + } + + @Test + public void testConcatCharArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new char[] {}, ArrayTools.concatCharArray(null)); + assertEquals(0, ArrayTools.concatCharArray(Collections.emptyList()).length); + } + + @Test + public void testConcatCharArray_ValidCollection_ReturnsConcatenatedArray() { + char[] expected = { 'a', 'b', 'c', 'd', 'e' }; + char[] result = ArrayTools.concatCharArray(charArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatByteArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new byte[0], ArrayTools.concatByteArray(null)); + assertEquals(0, ArrayTools.concatByteArray(Collections.emptyList()).length); + } + + @Test + public void testConcatByteArray_ValidCollection_ReturnsConcatenatedArray() { + byte[] expected = { 1, 2, 3, 4, 5 }; + byte[] result = ArrayTools.concatByteArray(byteArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatShortArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new short[0], ArrayTools.concatShortArray(null)); + assertEquals(0, ArrayTools.concatShortArray(Collections.emptyList()).length); + } + + @Test + public void testConcatShortArray_ValidCollection_ReturnsConcatenatedArray() { + short[] expected = { 10, 20, 30, 40, 50 }; + short[] result = ArrayTools.concatShortArray(shortArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatIntArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new int[0], ArrayTools.concatIntArray(null)); + assertEquals(0, ArrayTools.concatIntArray(Collections.emptyList()).length); + } + + @Test + public void testConcatIntArray_ValidCollection_ReturnsConcatenatedArray() { + int[] expected = { 100, 200, 300, 400, 500 }; + int[] result = ArrayTools.concatIntArray(intArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatLongArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new long[0], ArrayTools.concatLongArray(null)); + assertEquals(0, ArrayTools.concatLongArray(Collections.emptyList()).length); + } + + @Test + public void testConcatLongArray_ValidCollection_ReturnsConcatenatedArray() { + long[] expected = { 1000L, 2000L, 3000L, 4000L, 5000L }; + long[] result = ArrayTools.concatLongArray(longArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatFloatArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new float[0], ArrayTools.concatFloatArray(null)); + assertEquals(0, ArrayTools.concatFloatArray(Collections.emptyList()).length); + } + + @Test + public void testConcatFloatArray_ValidCollection_ReturnsConcatenatedArray() { + float[] expected = { 1000.1f, 2000.2f, 3000.3f, 4000.4f, 5000.5f }; + float[] result = ArrayTools.concatFloatArray(floatArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatDoubleArray_NullOrEmptyCollection_ReturnsEmptyArray() { + assertArrayEquals(new double[] {}, ArrayTools.concatDoubleArray(null)); + assertEquals(0, ArrayTools.concatDoubleArray(Collections.emptyList()).length); + } + + @Test + public void testConcatDoubleArray_ValidCollection_ReturnsConcatenatedArray() { + double[] expected = { 1000.1d, 2000.2d, 3000.3d, 4000.4d, 5000.5d }; + double[] result = ArrayTools.concatDoubleArray(doubleArrays); + assertArrayEquals(expected, result); + } + + @Test + public void testConcatToList_NullOrEmptyCollection_ReturnsEmptyList() { + assertTrue(ArrayTools.concatToList(null).isEmpty()); + assertTrue(ArrayTools.concatToList(Collections.emptyList()).isEmpty()); + } + + @Test + public void testConcatToList_ValidCollection_ReturnsConcatenatedList() { + Character[] charArray1 = { 'a', 'b' }; + Character[] charArray2 = { 'c', 'd', 'e' }; + List expected = Arrays.asList('a', 'b', 'c', 'd', 'e'); + List result = ArrayTools.concatToList(Arrays.asList(charArray1, charArray2)); + assertEquals(expected, result); + } + + // #endregion + + // #region - repeat + + @Test + void repeat_CharArray_TimesZero_ReturnsEmptyArray() { + char[] input = { 'a', 'b', 'c' }; + char[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_CHAR_ARRAY, result); + } + + @Test + void repeat_CharArray_TimesOne_ReturnsSameArray() { + char[] input = { 'a', 'b', 'c' }; + char[] result = ArrayTools.repeat(input, 1); + assertArrayEquals(input, result); + } + + @Test + void repeat_CharArray_TimesTwo_ReturnsRepeatedArray() { + char[] input = { 'a', 'b', 'c' }; + char[] expected = { 'a', 'b', 'c', 'a', 'b', 'c' }; + char[] result = ArrayTools.repeat(input, 2); + assertArrayEquals(expected, result); + } + + @Test + void repeat_CharArray_WithMaxLength_ReturnsTruncatedArray() { + char[] input = { 'a', 'b', 'c' }; + char[] expected = { 'a', 'b', 'c', 'a', 'b' }; + char[] result = ArrayTools.repeat(input, 2, 5); + assertArrayEquals(expected, result); + } + + @Test + void repeat_ByteArray_TimesZero_ReturnsEmptyArray() { + byte[] input = { 1, 2, 3 }; + byte[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_BYTE_ARRAY, result); + } + + @Test + void repeat_ShortArray_TimesZero_ReturnsEmptyArray() { + short[] input = { 1, 2, 3 }; + short[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_SHORT_ARRAY, result); + } + + @Test + void repeat_IntArray_TimesZero_ReturnsEmptyArray() { + int[] input = { 1, 2, 3 }; + int[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_INT_ARRAY, result); + } + + @Test + void repeat_LongArray_TimesZero_ReturnsEmptyArray() { + long[] input = { 1, 2, 3 }; + long[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_LONG_ARRAY, result); + } + + @Test + void repeat_FloatArray_TimesZero_ReturnsEmptyArray() { + float[] input = { 1, 2, 3 }; + float[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_FLOAT_ARRAY, result); + } + + @Test + void repeat_DoubleArray_TimesZero_ReturnsEmptyArray() { + double[] input = { 1, 2, 3 }; + double[] result = ArrayTools.repeat(input, 0); + assertArrayEquals(ArrayTools.EMPTY_DOUBLE_ARRAY, result); + } + + @Test + void repeat_CharArray_ThrowsExceptionForNullArray() { + Executable executable = () -> ArrayTools.repeat((char[]) null, 2); + assertThrows(IllegalArgumentException.class, executable); + } + + @Test + void repeat_CharArray_ThrowsExceptionForNegativeTimes() { + char[] input = { 'a', 'b', 'c' }; + Executable executable = () -> ArrayTools.repeat(input, -1); + assertThrows(IllegalArgumentException.class, executable); + } + + @Test + void repeat_CharArray_ThrowsExceptionForNegativeMaxLength() { + char[] input = { 'a', 'b', 'c' }; + Executable executable = () -> ArrayTools.repeat(input, 2, -1); + assertThrows(IllegalArgumentException.class, executable); + } + + // #endregion + + // TODO 【添加】 补充测试用例 + + // #region - fill + // #endregion + + // #region - indexOf + // #endregion + + // #region - lastIndexOf + // #endregion + + // #region - contains + // #endregion + }