数组工具类 - ArrayUtil

简介

ArrayUtil 是 Hutool 提供的一个针对数组操作的工具类，封装了常用的数组操作方法，如数组判空、数组合并、数组克隆、数组过滤等。该工具类解决了 Java 中原始类型数组和包装类型数组操作不统一的问题，并提供了许多便捷的方法来处理数组的操作。

1. 数组判空

ArrayUtil 提供了 isEmpty 和 isNotEmpty 方法用于判断数组是否为空或非空。这些方法适用于原始类型数组和泛型数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        int[] emptyArray = {};
        int[] nonEmptyArray = {1, 2, 3};

        // 判断数组是否为空
        boolean isEmpty = ArrayUtil.isEmpty(emptyArray);
        System.out.println("数组是否为空: " + isEmpty); // 结果：true

        // 判断数组是否为非空
        boolean isNotEmpty = ArrayUtil.isNotEmpty(nonEmptyArray);
        System.out.println("数组是否为非空: " + isNotEmpty); // 结果：true
    }
}

• isEmpty(Object array)：判断数组是否为空（null 或 长度为 0）。
• isNotEmpty(Object array)：判断数组是否为非空。

作用： 这些方法适用于需要快速检查数组是否为空或非空的场景，以避免空指针异常。

实际开发场景： 在进行数组操作之前，可以使用这些方法确保数组不为空，从而避免在后续操作中出现空指针异常。

2. 新建泛型数组

ArrayUtil 提供了 newArray 方法用于动态创建指定类型的数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        // 新建一个 String 类型的数组，长度为 3
        String[] newArray = ArrayUtil.newArray(String.class, 3);
        System.out.println("新建的数组长度: " + newArray.length); // 结果：3
    }
}

• newArray(Class<T> componentType, int length)：创建一个指定类型和长度的新数组。
  • componentType：数组元素的类型。
  • length：数组的长度。

作用： 该方法适用于需要动态创建指定类型数组的场景，避免强制类型转换的麻烦。

实际开发场景： 在需要动态创建数组的场景中，使用此方法可以简化代码并确保类型安全。

3. 调整数组大小

ArrayUtil 提供了 resize 方法，用于生成一个新的、调整了大小的数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3};

        // 调整数组大小，将原数组扩展到长度为 5
        int[] resizedArray = ArrayUtil.resize(originalArray, 5);
        System.out.println("调整大小后的数组长度: " + resizedArray.length); // 结果：5
    }
}

• resize(T[] array, int newSize)：调整数组大小，并生成一个新的数组。
  • array：要调整的数组。
  • newSize：新数组的长度。

作用： 该方法适用于需要对数组进行扩展或缩减的场景，可以保持数组内容的同时调整其大小。

实际开发场景： 在需要对数组进行扩容或缩减时，使用此方法可以保持原数据并调整数组大小。

4. 合并数组

ArrayUtil 提供了 addAll 方法，用于将多个泛型数组合并为一个数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        Integer[] array1 = {1, 2};
        Integer[] array2 = {3, 4};

        // 将两个数组合并为一个
        Integer[] mergedArray = ArrayUtil.addAll(array1, array2);
        System.out.println("合并后的数组: " + ArrayUtil.join(mergedArray, ",")); // 结果：1,2,3,4
    }
}

• addAll(T[] array1, T[] array2)：合并两个数组，并返回一个新的数组。
  • array1：第一个要合并的数组。
  • array2：第二个要合并的数组。

作用： 该方法适用于需要合并多个数组的场景，如合并结果集合、合并列表等。

实际开发场景： 在处理多个数据源并需要将其合并为一个数组时，可以使用此方法简化操作。

5. 克隆数组

ArrayUtil 提供了 clone 方法，用于克隆数组。它支持泛型数组和原始类型数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        Integer[] originalArray = {1, 2, 3};

        // 克隆数组
        Integer[] clonedArray = ArrayUtil.clone(originalArray);
        System.out.println("克隆后的数组: " + ArrayUtil.join(clonedArray, ",")); // 结果：1,2,3
    }
}

• clone(T[] array)：克隆泛型数组。
  • array：要克隆的数组。

作用： 该方法适用于需要对数组进行深拷贝的场景，确保操作的是数组的副本而非原数组。

实际开发场景： 在需要操作数组副本时，使用此方法可以避免对原数组的影响。

6. 数组过滤

ArrayUtil 提供了 filter 方法，用于过滤数组元素，只保留符合条件的元素。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        Integer[] originalArray = {1, 2, 3, 4, 5, 6};

        // 过滤数组，只保留偶数
        Integer[] filteredArray = ArrayUtil.filter(originalArray, (t) -> t % 2 == 0 ? t : null);
        System.out.println("过滤后的数组: " + ArrayUtil.join(filteredArray, ",")); // 结果：2,4,6
    }
}

• filter(T[] array, Editor<T> editor)：过滤数组元素，只保留符合条件的元素。
  • array：要过滤的数组。
  • editor：用于判断元素是否保留的逻辑。

作用： 该方法适用于需要对数组进行筛选的场景，只保留符合条件的元素。

实际开发场景： 在数据清洗或筛选过程中，使用此方法可以简化数组的过滤操作。

7. 判断对象是否为数组

ArrayUtil 提供了 isArray 方法，用于判断对象是否为数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};

        // 判断对象是否为数组
        boolean isArray = ArrayUtil.isArray(array);
        System.out.println("对象是否为数组: " + isArray); // 结果：true
    }
}

• isArray(Object obj)：判断对象是否为数组。
  • obj：要判断的对象。

作用： 该方法适用于需要判断某个对象是否为数组的场景，尤其是在泛型和反射操作中。

实际开发场景： 在处理不确定类型的对象时，使用此方法可以判断对象是否为数组，以便进行相应的操作。

8. 转换为字符串

ArrayUtil 提供了 toString 和 join 方法，用于将数组转换为字符串。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};

        // 将数组转换为字符串
        String arrayStr = ArrayUtil.toString(array);
        System.out.println("数组转换为字符串: " + arrayStr); // 结果：[1, 2, 3, 4]

        // 使用间隔符将数组转换为字符串
        String

 joinedStr = ArrayUtil.join(array, "-");
        System.out.println("数组转换为字符串（带间隔符）: " + joinedStr); // 结果：1-2-3-4
    }
}

• toString(Object array)：将数组转换为字符串，支持原始类型数组和泛型数组。
  • array：要转换的数组。
• join(T[] array, CharSequence delimiter)：使用指定的间隔符将数组转换为字符串。
  • array：要转换的数组。
  • delimiter：间隔符。

作用： 这些方法适用于需要将数组内容以字符串形式输出的场景，如日志打印、调试输出等。

实际开发场景： 在输出数组内容或生成报告时，可以使用这些方法将数组转换为易读的字符串格式。

9. 数组合并

ArrayUtil 提供了 addAll 方法，用于将多个泛型数组合并为一个数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        Integer[] array1 = {1, 2};
        Integer[] array2 = {3, 4};

        // 将两个数组合并为一个
        Integer[] mergedArray = ArrayUtil.addAll(array1, array2);
        System.out.println("合并后的数组: " + ArrayUtil.join(mergedArray, ",")); // 结果：1,2,3,4
    }
}

• addAll(T[] array1, T[] array2)：合并两个数组，并返回一个新的数组。
  • array1：第一个要合并的数组。
  • array2：第二个要合并的数组。

作用： 该方法适用于需要合并多个数组的场景，如合并结果集合、合并列表等。

实际开发场景： 在处理多个数据源并需要将其合并为一个数组时，可以使用此方法简化操作。

10. 包装和拆包

ArrayUtil 提供了 wrap 和 unwrap 方法，用于将原始类型数组转换为包装类型数组，或将包装类型数组转换为原始类型数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        int[] primitiveArray = {1, 2, 3};

        // 将原始类型数组包装为包装类型数组
        Integer[] wrappedArray = ArrayUtil.wrap(primitiveArray);
        System.out.println("包装后的数组: " + ArrayUtil.join(wrappedArray, ",")); // 结果：1,2,3

        // 将包装类型数组拆包为原始类型数组
        int[] unwrappedArray = ArrayUtil.unwrap(wrappedArray);
        System.out.println("拆包后的数组: " + ArrayUtil.join(unwrappedArray, ",")); // 结果：1,2,3
    }
}

• wrap(int[] array)：将原始类型数组包装为包装类型数组。
  • array：要包装的原始类型数组。
• unwrap(Integer[] array)：将包装类型数组拆包为原始类型数组。
  • array：要拆包的包装类型数组。

作用： 这些方法适用于需要在原始类型数组和包装类型数组之间进行转换的场景。

实际开发场景： 在处理泛型或需要与原始类型数组兼容的场景中，可以使用这些方法进行数组的包装和拆包操作。

11. 数组克隆

ArrayUtil 提供了 clone 方法，用于克隆数组。它支持泛型数组和原始类型数组。

import cn.hutool.core.util.ArrayUtil;

public class ArrayUtilExample {
    public static void main(String[] args) {
        Integer[] originalArray = {1, 2, 3};

        // 克隆数组
        Integer[] clonedArray = ArrayUtil.clone(originalArray);
        System.out.println("克隆后的数组: " + ArrayUtil.join(clonedArray, ",")); // 结果：1,2,3
    }
}

• clone(T[] array)：克隆泛型数组。
  • array：要克隆的数组。

作用： 该方法适用于需要对数组进行深拷贝的场景，确保操作的是数组的副本而非原数组。

实际开发场景： 在需要操作数组副本时，使用此方法可以避免对原数组的影响。

---

通过 ArrayUtil 提供的丰富功能，可以有效简化对数组的各种操作。无论是数组的判空、合并、克隆、包装，还是对数组进行过滤和转换，这些工具方法都能在实际开发中带来极大的便利。