java数组操作工具类

Java数组操作大全:从Arrays工具类到Stream API实战指南 数组是Java中最基础的数据结构,用于存储固定大小的同类型元素集合。其核心原理在于通过索引直接访问连续内存空间,具有O(1)的随机访问效率。在Java中,数组本身方法有限,但通过java.util.Arrays工具类提供了丰富的静态方法,极大提升了开发效率与代码可读性。这些方法涵盖了数组的创建、填充、复制、排序、查找和比较等常见操作,是处理批量数据的利器。例如,Arrays.sort()方法内部根据数据类型智能选择Dual-Pivot Quicksort或TimSort算法,而binarySearch()则 阅读详情
package com.zuidaima.util.common;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * 数组操作辅助类,支持int,char,boject,String类型
 *@author www.zuidaima.com
 */
public class ArrayHelper {

    /**
     * 锁定创建
     */
    private ArrayHelper() {
    }
    /**
     * 
     * 计算数组中的单元数目或对象中的属性个数
     * 当 arr 为 null 时返回 0。
     * 
     * @param arr
     * @return
     */
    public static int sizeOf(int[] arr) {
        return arr == null ? 0 : arr.length;
    }

    /**
     * 
     * 合并一个或多个数组
     * 当 arr 为 null 时返回 new int[0] 。
     * 
     * @param arrs
     * @return
     */
    public static int[] merge(int[]... arrs) {
        int[] result = new int[0];
        if (arrs != null) {
            int count = 0;
            for (int i = 0; i < arrs.length; i++) {
                count += arrs[i].length;
            }
            result = new int[count];
            int arg;
            int k = 0;
            for (int i = 0; i < arrs.length; i++) {
                if (arrs[i] == null) {
                    continue;
                }
                for (int j = 0; j < arrs[i].length; j++) {
                    arg = arrs[i][j];
                    result[k] = arg;
                    k++;
                }
            }
        }
        return result;
    }

    /**
     * 
     * 计算数组的差集
     * 注意:
     *     aArr 为null时 返回 bArr(可能为 null)。
     *     bArr 为null时 返回 aArr。
     *     无差集时返回 new int[0];
     * 
     * @param aArr
     * @param bArr
     * @return
     */
    public static int[] diff(int[] aArr, int[] bArr) {
        {
            if (aArr == null) {
                return bArr;
            }
            if (bArr == null) {
                return aArr;
            }
        }
        int[] cArr = new int[aArr.length + bArr.length];
        int idx = 0;
        /**
         * 检查 a 中那些元 在 b 中不存在
         */
        for (int i = 0; i < aArr.length; i++) {
            if (!inArray(bArr, aArr[i])) {
                cArr[idx++] = aArr[i];
            }
        }
        /**
         * 检查 b 中那些元 在 a 中不存在
         */
        for (int i = 0; i < bArr.length; i++) {
            if (!inArray(aArr, bArr[i])) {
                cArr[idx++] = bArr[i];
            }
        }
        //
        int[] dArr = new int[idx];
        System.arraycopy(cArr, 0, dArr, 0, dArr.length);
        return dArr;
    }

    /**
     * 
     * 返回一个数组的全复制
     * 当 arr 为 null 时返回 new int[0]  。
     * 
     * @param arr
     * @return
     */
    public static int[] copyOf(int[] arr) {
        int[] carr = new int[0];
        if (arr != null) {
            carr = new int[arr.length];
            System.arraycopy(arr, 0, carr, 0, arr.length);
        }
        return carr;
    }

    /**
     * 
     * 返回一个数组的复制
     * 当 arr 为 null 时返回 new int[0] 。
     * 
     * @param arr
     * @param i
     * @return
     */
    public static int[] copyOf(int[] arr, int i) {
        int[] carr = new int[0];
        if (arr != null) {
            if (i > arr.length) {
                i = arr.length;
            }
            carr = new int[i];
            System.arraycopy(arr, 0, carr, 0, i);
        }
        return carr;
    }

    /**
     * 
     * 创建一个Map,用一个数组的值作为其键名,另一个数组的值作为其值
     * 当键为空或无单元时返回空Map,否则以键数组为主导填充Map。值不足时填充null。
     * 注意:Map中键顺序并不一定与参数keys顺序相同。
     * @param <T>
     * @param <V>
     * @param keys
     * @param values
     * @return
     */
    public static <T, V> Map<T, V> combine(T[] keys, V[] values) {
        Map<T, V> map = new HashMap<T, V>();
        if (keys != null && keys.length > 0) {
            int vsize = values == null ? 0 : values.length;
            for (int i = 0; i < keys.length; i++) {
                if (i >= vsize) {
                    map.put(keys[i], null);
                } else {
                    map.put(keys[i], values[i]);
                }
            }
        }
        return map;
    }

    /**
     * 
     * 从数组中随机取出一个或多个单元
     * 当 arr 为 null 时返回 new int[0]。
     * 
     * @param arr
     * @return
     */
    public static int[] random(int[] arr) {
        if (arr == null) {
            return new int[0];
        }
        int count = new Random().nextInt(arr.length);
        count = count > 0 ? count : 1;
        return random(arr, count);
    }

    /**
     * 
     * 将数组打乱
     * 当 arr 为 null 时返回 new int[0]。
     * 
     * @param arr
     * @return
     */
    public static int[] shuffle(int[] arr) {
        if (arr == null) {
            return new int[0];
        }
        return random(arr, arr.length);
    }

    /**
     * 
     * 随机取出固定数量的元素
     * 如取出数量大于数组元素数则返回打乱的数组,等同于 {@link #shuffle}
     * 当 arr 为 null 时返回 new int[0]。
     * 
     * @param arr
     * @param count
     * @return
     */
    public static int[] random(int[] arr, int count) {
        int[] rarr = new int[0];
        if (arr != null) {
            if (arr.length < count) {
                count = arr.length;
            }
            Random random = new Random();
            int i = 0;
            int num = 0;
            rarr = new int[count];
            int[] keys = new int[count];
            for (int j = 0; j < keys.length; j++) {
                keys[j] = -1;
            }
            do {
                num = random.nextInt(arr.length);
                if (!inArray(keys, num)) {
                    keys[i] = num;
                    rarr[i] = arr[num];
                    i++;
                }
            } while (i < count);
        }
        return rarr;
    }

    /**
     * 
     * 检查数组中是否存在某个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(int[] arr, int search) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == search) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某几个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(int[] arr, int[] search) {
        if (search != null) {
            for (int i = 0; i < search.length; i++) {
                if (!inArray(arr, search[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某个值,并返回其索引键,不存在则返回 -1 。
     * 
     * @param arr
     * @param search
     * @return
     */
    public static int search(int[] arr, int search) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == search) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 
     * 返回一个单元顺序相反的数组 
     * 当 arr 为 null 时返回 new int[0]。
     * 
     * @param arr
     * @return
     */
    public static int[] reverse(int[] arr) {
        int[] rarr = new int[0];
        if (arr != null) {
            rarr = new int[arr.length];
            int j = 0;
            for (int i = arr.length - 1; i >= 0; i--) {
                rarr[j++] = arr[i];
            }
        }
        return rarr;
    }

    /**
     * 使用间隔符连接
     * @param ints
     * @param sep
     * @return
     */
    public static String join(int[] ints, String sep) {
        StringBuilder strBuilder = new StringBuilder();
        if (ints != null) {
            for (int i = 0; i < ints.length; i++) {
                strBuilder.append(ints[i]);
                if (i < ints.length - 1) {
                    strBuilder.append(sep);
                }
            }
        }
        return strBuilder.toString();
    }

    /**
     * 计算所有单元的合
     * @param ints
     * @param sep
     * @return
     */
    public static int sum(int[] ints) {
        int sum = 0;
        if (ints != null) {
            for (int i = 0; i < ints.length; i++) {
                sum += ints[i];
            }
        }
        return sum;
    }

    /**
     * char array tools
     * =====================
     */
    /**
     * 
     * 计算数组中的单元数目或对象中的属性个数
     * 当 arr 为 null 时返回 0。
     * 
     * @param arr
     * @return
     */
    public static int sizeOf(char[] arr) {
        return arr == null ? 0 : arr.length;
    }

    /**
     * 
     * 合并一个或多个数组
     * 当 arr 为 null 时返回 new char[0] 。
     * 
     * @param arrs
     * @return
     */
    public static char[] merge(char[]... arrs) {
        char[] result = new char[0];
        if (arrs != null) {
            char count = 0;
            for (char i = 0; i < arrs.length; i++) {
                count += arrs[i].length;
            }
            result = new char[count];
            char arg;
            char k = 0;
            for (char i = 0; i < arrs.length; i++) {
                if (arrs[i] == null) {
                    continue;
                }
                for (char j = 0; j < arrs[i].length; j++) {
                    arg = arrs[i][j];
                    result[k] = arg;
                    k++;
                }
            }
        }
        return result;
    }

    /**
     * 
     * 计算数组的差集
     * 注意:
     *     aArr 为null时 返回 bArr(可能为 null)。
     *     bArr 为null时 返回 aArr。
     *     无差集时返回 new char[0];
     * 
     * @param aArr
     * @param bArr
     * @return
     */
    public static char[] diff(char[] aArr, char[] bArr) {
        {
            if (aArr == null) {
                return bArr;
            }
            if (bArr == null) {
                return aArr;
            }
        }
        char[] cArr = new char[aArr.length + bArr.length];
        char idx = 0;
        /**
         * 检查 a 中那些元 在 b 中不存在
         */
        for (int i = 0; i < aArr.length; i++) {
            if (!inArray(bArr, aArr[i])) {
                cArr[idx++] = aArr[i];
            }
        }
        /**
         * 检查 b 中那些元 在 a 中不存在
         */
        for (int i = 0; i < bArr.length; i++) {
            if (!inArray(aArr, bArr[i])) {
                cArr[idx++] = bArr[i];
            }
        }
        //
        char[] dArr = new char[idx];
        System.arraycopy(cArr, 0, dArr, 0, dArr.length);
        return dArr;
    }

    /**
     * 
     * 返回一个数组的全复制
     * 当 arr 为 null 时返回 new char[0]  。
     * 
     * @param arr
     * @return
     */
    public static char[] copyOf(char[] arr) {
        char[] carr = new char[0];
        if (arr != null) {
            carr = new char[arr.length];
            System.arraycopy(arr, 0, carr, 0, arr.length);
        }
        return carr;
    }

    /**
     * 
     * 返回一个数组的复制
     * 当 arr 为 null 时返回 new char[0] 。
     * 
     * @param arr
     * @param i
     * @return
     */
    public static char[] copyOf(char[] arr, int i) {
        char[] carr = new char[0];
        if (arr != null) {
            if (i > arr.length) {
                i = arr.length;
            }
            carr = new char[i];
            System.arraycopy(arr, 0, carr, 0, i);
        }
        return carr;
    }

    /**
     * 
     * 从数组中随机取出一个或多个单元
     * 当 arr 为 null 时返回 new char[0]。
     * 
     * @param arr
     * @return
     */
    public static char[] random(char[] arr) {
        if (arr == null) {
            return new char[0];
        }
        int count = new Random().nextInt(arr.length);
        count = count > 0 ? count : 1;
        return random(arr, count);
    }

    /**
     * 
     * 将数组打乱
     * 当 arr 为 null 时返回 new char[0]。
     * 
     * @param arr
     * @return
     */
    public static char[] shuffle(char[] arr) {
        if (arr == null) {
            return new char[0];
        }
        return random(arr, arr.length);
    }

    /**
     * 
     * 随机取出固定数量的元素
     * 如取出数量大于数组元素数则返回打乱的数组,等同于 {@link #shuffle}
     * 当 arr 为 null 时返回 new char[0]。
     * 
     * @param arr
     * @param count
     * @return
     */
    public static char[] random(char[] arr, int count) {
        char[] rarr = new char[0];
        if (arr != null) {
            if (arr.length < count) {
                count = arr.length;
            }
            Random random = new Random();
            int i = 0;
            int num = 0;
            rarr = new char[count];
            int[] keys = new int[count];
            for (int j = 0; j < keys.length; j++) {
                keys[j] = 0;
            }
            do {
                num = random.nextInt(arr.length);
                if (!inArray(keys, num)) {
                    keys[i] = num;
                    rarr[i] = arr[num];
                    i++;
                }
            } while (i < count);
        }
        return rarr;
    }

    /**
     * 
     * 检查数组中是否存在某个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(char[] arr, char search) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == search) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某几个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(char[] arr, char[] search) {
        if (search != null) {
            for (int i = 0; i < search.length; i++) {
                if (!inArray(arr, search[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某个值,并返回其索引键,不存在则返回 -1 。
     * 
     * @param arr
     * @param search
     * @return
     */
    public static int search(char[] arr, char search) {
        if (arr != null) {
            for (char i = 0; i < arr.length; i++) {
                if (arr[i] == search) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 
     * 返回一个单元顺序相反的数组
     * 当 arr 为 null 时返回 new char[0]。
     * 
     * @param arr
     * @return
     */
    public static char[] reverse(char[] arr) {
        char[] rarr = new char[0];
        if (arr != null) {
            rarr = new char[arr.length];
            char j = 0;
            for (int i = arr.length - 1; i >= 0; i--) {
                rarr[j++] = arr[i];
            }
        }
        return rarr;
    }

    /**
     * byte array tools
     * =====================
     */
    /**
     * 
     * 计算数组中的单元数目或对象中的属性个数
     * 当 arr 为 null 时返回 0。
     * 
     * @param arr
     * @return
     */
    public static int sizeOf(byte[] arr) {
        return arr == null ? 0 : arr.length;
    }

    /**
     * 
     * 合并一个或多个数组
     * 当 arr 为 null 时返回 new byte[0] 。
     * 
     * @param arrs
     * @return
     */
    public static byte[] merge(byte[]... arrs) {
        byte[] result = new byte[0];
        if (arrs != null) {
            byte count = 0;
            for (byte i = 0; i < arrs.length; i++) {
                count += arrs[i].length;
            }
            result = new byte[count];
            byte arg;
            byte k = 0;
            for (byte i = 0; i < arrs.length; i++) {
                if (arrs[i] == null) {
                    continue;
                }
                for (byte j = 0; j < arrs[i].length; j++) {
                    arg = arrs[i][j];
                    result[k] = arg;
                    k++;
                }
            }
        }
        return result;
    }

    /**
     * 
     * 计算数组的差集
     * 注意:
     *     aArr 为null时 返回 bArr(可能为 null)。
     *     bArr 为null时 返回 aArr。
     *     无差集时返回 new byte[0];
     * 
     * @param aArr
     * @param bArr
     * @return
     */
    public static byte[] diff(byte[] aArr, byte[] bArr) {
        {
            if (aArr == null) {
                return bArr;
            }
            if (bArr == null) {
                return aArr;
            }
        }
        byte[] cArr = new byte[aArr.length + bArr.length];
        byte idx = 0;
        /**
         * 检查 a 中那些元 在 b 中不存在
         */
        for (int i = 0; i < aArr.length; i++) {
            if (!inArray(bArr, aArr[i])) {
                cArr[idx++] = aArr[i];
            }
        }
        /**
         * 检查 b 中那些元 在 a 中不存在
         */
        for (int i = 0; i < bArr.length; i++) {
            if (!inArray(aArr, bArr[i])) {
                cArr[idx++] = bArr[i];
            }
        }
        //
        byte[] dArr = new byte[idx];
        System.arraycopy(cArr, 0, dArr, 0, dArr.length);
        return dArr;
    }

    /**
     * 
     * 返回一个数组的全复制
     * 当 arr 为 null 时返回 new byte[0]  。
     * 
     * @param arr
     * @return
     */
    public static byte[] copyOf(byte[] arr) {
        byte[] carr = new byte[0];
        if (arr != null) {
            carr = new byte[arr.length];
            System.arraycopy(arr, 0, carr, 0, arr.length);
        }
        return carr;
    }

    /**
     * 
     * 返回一个数组的复制
     * 当 arr 为 null 时返回 new byte[0] 。
     * 
     * @param arr
     * @param i
     * @return
     */
    public static byte[] copyOf(byte[] arr, int i) {
        byte[] carr = new byte[0];
        if (arr != null) {
            if (i > arr.length) {
                i = arr.length;
            }
            carr = new byte[i];
            System.arraycopy(arr, 0, carr, 0, i);
        }
        return carr;
    }

    /**
     * 
     * 从数组中随机取出一个或多个单元
     * 当 arr 为 null 时返回 new byte[0]。
     * 
     * @param arr
     * @return
     */
    public static byte[] random(byte[] arr) {
        if (arr == null) {
            return new byte[0];
        }
        int count = new Random().nextInt(arr.length);
        count = count > 0 ? count : 1;
        return random(arr, count);
    }

    /**
     * 
     * 将数组打乱
     * 当 arr 为 null 时返回 new byte[0]。
     * 
     * @param arr
     * @return
     */
    public static byte[] shuffle(byte[] arr) {
        if (arr == null) {
            return new byte[0];
        }
        return random(arr, arr.length);
    }

    /**
     * 
     * 随机取出固定数量的元素
     * 如取出数量大于数组元素数则返回打乱的数组,等同于 {@link #shuffle}
     * 当 arr 为 null 时返回 new byte[0]。
     * 
     * @param arr
     * @param count
     * @return
     */
    public static byte[] random(byte[] arr, int count) {
        byte[] rarr = new byte[0];
        if (arr != null) {
            if (arr.length < count) {
                count = arr.length;
            }
            Random random = new Random();
            int i = 0;
            int num = 0;
            rarr = new byte[count];
            int[] keys = new int[count];
            for (int j = 0; j < keys.length; j++) {
                keys[j] = 0;
            }
            do {
                num = random.nextInt(arr.length);
                if (!inArray(keys, num)) {
                    keys[i] = num;
                    rarr[i] = arr[num];
                    i++;
                }
            } while (i < count);
        }
        return rarr;
    }

    /**
     * 
     * 检查数组中是否存在某个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(byte[] arr, byte search) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == search) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某几个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(byte[] arr, byte[] search) {
        if (search != null) {
            for (int i = 0; i < search.length; i++) {
                if (!inArray(arr, search[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某个值,并返回其索引键,不存在则返回 -1 。
     * 
     * @param arr
     * @param search
     * @return
     */
    public static int search(byte[] arr, byte search) {
        if (arr != null) {
            for (byte i = 0; i < arr.length; i++) {
                if (arr[i] == search) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 返回一个单元顺序相反的数组<br />
     * 当 arr 为 null 时返回 new byte[0]。
     * @param arr
     * @return
     */
    public static byte[] reverse(byte[] arr) {
        byte[] rarr = new byte[0];
        if (arr != null) {
            rarr = new byte[arr.length];
            byte j = 0;
            for (int i = arr.length - 1; i >= 0; i--) {
                rarr[j++] = arr[i];
            }
        }
        return rarr;
    }

    /**
     * 使用 Byte List填充一个byte array。(转换Byte List为byte array)
     * @param list 
     * @return 当 list 为 null 时返回 new byte[0]。
     */
    public static byte[] fill(List<Byte> list) {
        if (list == null) {
            return new byte[0];
        }
        int size = list.size();
        byte[] arr = new byte[size];

        for (int i = 0; i < size; i++) {
            arr[i] = list.get(i);
        }
        return arr;
    }

    /**
     * 使用 byte array填充一个 Byte List。(转换byte array为Byte List)
     * @param arr
     * @return 当 arr 为 null 时返回 new ArrayList<Byte>(size)。
     */
    public static List<Byte> fill(byte[] arr) {
        List<Byte> list = null;
        if (arr == null) {
            return new ArrayList<Byte>(0);
        }
        int size = arr.length;
        list = new ArrayList<Byte>(size);
        for (byte by : arr) {
            list.add(by);
        }
        return list;
    }

    /**
     * Object array tools
     * =====================
     */
    /**
     * 
     * 计算数组中的单元数目或对象中的属性个数
     * 当 arr 为 null 时返回 0。
     * 
     * @param arr
     * @return
     */
    public static int sizeOf(Object[] arr) {
        return arr == null ? 0 : arr.length;
    }

    /**
     * 
     * 合并一个或多个数组
     * 当 arr 为 null 时返回 new Object[0]。
     * 
     * @param arrs
     * @return
     */
    public static Object[] merge(Object[]... arrs) {
        Object[] result = new Object[0];
        if (arrs != null) {
            int count = 0;
            for (int i = 0; i < arrs.length; i++) {
                count += arrs[i].length;
            }
            result = new Object[count];
            Object arg;
            int k = 0;
            for (int i = 0; i < arrs.length; i++) {
                if (arrs[i] == null) {
                    continue;
                }
                for (int j = 0; j < arrs[i].length; j++) {
                    arg = arrs[i][j];
                    result[k] = arg;
                    k++;
                }
            }
        }
        return result;
    }

    /**
     * 
     * 计算数组的差集
     * 注意:
     *     aArr 为null时 返回 bArr(可能为 null)。
     *     bArr 为null时 返回 aArr。
     *     无差集时返回 new Object[0];
     * 
     * @param aArr
     * @param bArr
     * @return
     */
    public static Object[] diff(Object[] aArr, Object[] bArr) {
        {
            if (aArr == null) {
                return bArr;
            }
            if (bArr == null) {
                return aArr;
            }
        }
        Object[] cArr = new Object[aArr.length + bArr.length];
        int idx = 0;
        /**
         * 检查 a 中那些元 在 b 中不存在
         */
        for (int i = 0; i < aArr.length; i++) {
            if (!inArray(bArr, aArr[i])) {
                cArr[idx++] = aArr[i];
            }
        }
        /**
         * 检查 b 中那些元 在 a 中不存在
         */
        for (int i = 0; i < bArr.length; i++) {
            if (!inArray(aArr, bArr[i])) {
                cArr[idx++] = bArr[i];
            }
        }
        //
        Object[] dArr = new Object[idx];
        System.arraycopy(cArr, 0, dArr, 0, dArr.length);
        return dArr;
    }

    /**
     * 
     * 返回一个数组的全复制
     * 当 arr 为 null 时返回 new int[0] 。
     * 
     * @param arr
     * @return
     */
    public static Object[] copyOf(Object[] arr) {
        Object[] carr = new Object[0];
        if (arr != null) {
            carr = new Object[arr.length];
            System.arraycopy(arr, 0, carr, 0, arr.length);
        }
        return carr;
    }

    /**
     * 
     * 返回一个数组的复制
     * 当 arr 为 null 时返回 new Object[0] 。
     * 
     * @param arr
     * @param i 
     * @return
     */
    public static Object[] copyOf(Object[] arr, int i) {
        Object[] carr = new Object[0];
        if (arr != null) {
            if (i > arr.length) {
                i = arr.length;
            }
            carr = new Object[i];
            System.arraycopy(arr, 0, carr, 0, i);
        }
        return carr;
    }

    /**
     * 
     * 从数组中随机取出一个或多个单元
     * 当 arr 为 null 时返回 new Object[0]。
     * 
     * @param arr
     * @return
     */
    public static Object[] random(Object[] arr) {
        if (arr == null) {
            return new Object[0];
        }
        int count = new Random().nextInt(arr.length);
        count = count > 0 ? count : 1;
        return random(arr, count);
    }

    /**
     * 
     * 将数组打乱
     * 当 arr 为 null 时返回 new Object[0]。
     * 
     * @param arr
     * @return
     */
    public static Object[] shuffle(Object[] arr) {
        if (arr == null) {
            return new Object[0];
        }
        return random(arr, arr.length);
    }

    /**
     * 
     * 随机取出固定数量的元素
     * 如取出数量大于数组元素数则返回打乱的数组,等同于 {@link #shuffle}
     * 当 arr 为 null 时返回 new Object[0]。
     * 
     * @param arr
     * @param count
     * @return
     */
    public static Object[] random(Object[] arr, int count) {
        Object[] rarr = new Object[0];
        if (arr != null) {
            if (arr.length < count) {
                count = arr.length;
            }
            Random random = new Random();
            int i = 0;
            int num = 0;
            rarr = new Object[count];
            int[] keys = new int[count];
            for (int j = 0; j < keys.length; j++) {
                keys[j] = -1;
            }
            do {
                num = random.nextInt(arr.length);
                if (!inArray(keys, num)) {
                    keys[i] = num;
                    rarr[i] = arr[num];
                    i++;
                }
            } while (i < count);
        }
        return rarr;
    }

    /**
     * 
     * 检查数组中是否存在某个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(Object[] arr, Object search) {
        if (arr != null && search != null) {
            for (int i = 0; i < arr.length; i++) {
                if (search.equals(arr[i])) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某几个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(Object[] arr, Object[] search) {
        if (search != null) {
            for (int i = 0; i < search.length; i++) {
                if (!inArray(arr, search[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某个值,并返回其索引键,不存在则返回 -1 。
     * 
     * @param arr
     * @param search
     * @return
     */
    public static int search(Object[] arr, Object search) {
        if (arr != null && search != null) {
            for (int i = 0; i < arr.length; i++) {
                if (search.equals(arr[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 
     * 返回一个单元顺序相反的数组
     * 当 arr 为 null 时返回 new Object[0]。
     * 
     * @param arr
     * @return
     */
    public static Object[] reverse(Object[] arr) {
        Object[] rarr = new Object[0];
        if (arr != null) {
            rarr = new Object[arr.length];
            int j = 0;
            for (int i = arr.length - 1; i >= 0; i--) {
                rarr[j++] = arr[i];
            }
        }
        return rarr;
    }

    /**
     * String array tools
     * =====================
     */
    /**
     * 
     * 计算数组中的单元数目或对象中的属性个数
     * 当 arr 为 null 时返回 0。
     * 
     * @param arr
     * @return
     */
    public static int sizeOf(String[] arr) {
        return arr == null ? 0 : arr.length;
    }

    /**
     * 
     * 合并一个或多个数组
     * 当 arr 为 null 时返回 new String[0]。
     * 
     * @param arrs
     * @return
     */
    public static String[] merge(String[]... arrs) {
        String[] result = new String[0];
        if (arrs != null) {
            int count = 0;
            for (int i = 0; i < arrs.length; i++) {
                count += arrs[i].length;
            }
            result = new String[count];
            String arg;
            int k = 0;
            for (int i = 0; i < arrs.length; i++) {
                if (arrs[i] == null) {
                    continue;
                }
                for (int j = 0; j < arrs[i].length; j++) {
                    arg = arrs[i][j];
                    result[k] = arg;
                    k++;
                }
            }
        }
        return result;
    }

    /**
     * 
     * 计算数组的差集
     * 注意:
     *     aArr 为null时 返回 bArr(可能为 null)。
     *     bArr 为null时 返回 aArr。
     *     无差集时返回 new String[0];
     * 
     * @param aArr
     * @param bArr
     * @return
     */
    public static String[] diff(String[] aArr, String[] bArr) {
        {
            if (aArr == null) {
                return bArr;
            }
            if (bArr == null) {
                return aArr;
            }
        }
        String[] cArr = new String[aArr.length + bArr.length];
        int idx = 0;
        /**
         * 检查 a 中那些元 在 b 中不存在
         */
        for (int i = 0; i < aArr.length; i++) {
            if (!inArray(bArr, aArr[i])) {
                cArr[idx++] = aArr[i];
            }
        }
        /**
         * 检查 b 中那些元 在 a 中不存在
         */
        for (int i = 0; i < bArr.length; i++) {
            if (!inArray(aArr, bArr[i])) {
                cArr[idx++] = bArr[i];
            }
        }
        //
        String[] dArr = new String[idx];
        System.arraycopy(cArr, 0, dArr, 0, dArr.length);
        return dArr;
    }

    /**
     * 
     * 返回一个数组的全复制
     * 当 arr 为 null 时返回 new String[0] 。
     * 
     * @param arr
     * @return
     */
    public static String[] copyOf(String[] arr) {
        String[] carr = new String[0];
        if (arr != null) {
            carr = new String[arr.length];
            System.arraycopy(arr, 0, carr, 0, arr.length);
        }
        return carr;
    }

    /**
     * 
     * 返回一个数组的复制
     * 当 arr 为 null 时返回 new String[0] 。
     * 
     * @param arr
     * @param i
     * @return
     */
    public static String[] copyOf(String[] arr, int i) {
        String[] carr = new String[0];
        if (arr != null) {
            if (i > arr.length) {
                i = arr.length;
            }
            carr = new String[i];
            System.arraycopy(arr, 0, carr, 0, i);
        }
        return carr;
    }

    /**
     * 
     * 从数组中随机取出一个或多个单元
     * 当 arr 为 null 时返回  new String[0] 。
     * 
     * @param arr
     * @return
     */
    public static String[] random(String[] arr) {
        if (arr == null) {
            return new String[0];
        }
        int count = new Random().nextInt(arr.length);
        count = count > 0 ? count : 1;
        return random(arr, count);
    }

    /**
     * 
     * 将数组打乱
     * 当 arr 为 null 时返回 new String[0] 。
     * 
     * @param arr
     * @return
     */
    public static String[] shuffle(String[] arr) {
        if (arr == null) {
            return new String[0];
        }
        return random(arr, arr.length);
    }

    /**
     * 
     * 随机取出固定数量的元素
     * 如取出数量大于数组元素数则返回打乱的数组,等同于 {@link #shuffle}
     * 当 arr 为 null 时返回 new String[0] 。
     * 
     * @param arr
     * @param count
     * @return
     */
    public static String[] random(String[] arr, int count) {
        String[] rarr = new String[0];
        if (arr != null) {
            if (arr.length < count) {
                count = arr.length;
            }
            Random random = new Random();
            int i = 0;
            int num = 0;
            rarr = new String[count];
            int[] keys = new int[count];
            for (int j = 0; j < keys.length; j++) {
                keys[j] = -1;
            }
            do {
                num = random.nextInt(arr.length);
                if (!inArray(keys, num)) {
                    keys[i] = num;
                    rarr[i] = arr[num];
                    i++;
                }
            } while (i < count);
        }
        return rarr;
    }

    /**
     * 
     * 检查数组中是否存在某个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(String[] arr, String search) {
        if (arr != null && search != null) {
            for (int i = 0; i < arr.length; i++) {
                if (search.equals(arr[i])) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某几个值
     * 
     * @param arr
     * @param search
     * @return
     */
    public static boolean inArray(String[] arr, String[] search) {
        if (search != null) {
            for (int i = 0; i < search.length; i++) {
                if (!inArray(arr, search[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 
     * 检查数组中是否存在某个值,并返回其索引键,不存在则返回 -1 。
     * 
     * @param arr
     * @param search
     * @return
     */
    public static int search(String[] arr, String search) {
        if (arr != null && search != null) {
            for (int i = 0; i < arr.length; i++) {
                if (search.equals(arr[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 
     * 返回一个单元顺序相反的数组
     * 当 arr 为 null 时返回 new String[0] 。
     * 
     * @param arr
     * @return
     */
    public static String[] reverse(String[] arr) {
        String[] rarr = new String[0];
        if (arr != null) {
            rarr = new String[arr.length];
            int j = 0;
            for (int i = arr.length - 1; i >= 0; i--) {
                rarr[j++] = arr[i];
            }
        }
        return rarr;
    }

    /**
     * 使用间隔符连接
     * @param strs
     * @param sep
     * @return
     */
    public static String join(String[] strs, String sep) {
        StringBuilder strBuilder = new StringBuilder();
        if (strs != null) {
            for (int i = 0; i < strs.length; i++) {
                strBuilder.append(strs[i]);
                if (i < strs.length - 1) {
                    strBuilder.append(sep);
                }
            }
        }
        return strBuilder.toString();
    }
}

原文:java数组操作工具类

源代码下载地址:http://www.zuidaima.com/share/1550463350262784.htm

从零到一:用ROS2和Gazebo搭建Franka机械臂仿真环境(避坑指南) 本文详细介绍了如何使用ROS2和Gazebo从零开始搭建Franka机械臂的仿真环境,包括环境准备、ROS2包安装、控制器配置及常见问题解决方案。特别针对关节位置控制等核心功能提供了实用代码示例和避坑指南,帮助开发者高效构建机器人算法验证平台。 阅读详情

相关推荐

避坑指南:Blender Eevee三渲二常见5大材质问题及解决方法

本文针对Blender Eevee引擎进行三渲二创作时常见的5大材质问题,提供了详细的排查与修复方案。重点解决了阴影锯齿、自发光过度、描边断裂、高光控制不当及节点管理混乱等痛点,通过沃罗诺伊纹理、着色器转RGB、实体化修改器等核心技巧,帮助创作者实现更专业、风格化的卡通渲染效果,提升作品艺术表现力。

weixin_29309785的博客 453

Java基础(九)数组工具类

数组工具类

bao_14440的博客 600

2025-E题国一-简易自行瞄准装置:基于嘉立创地猛星/天猛星与K230的视觉巡线云台系统设计

本文详细介绍了2025年全国大学生电子设计竞赛E题一等奖作品——基于嘉立创地猛星/天猛星与K230的视觉巡线云台系统设计。该系统通过地猛星主控实现小车巡线,天猛星主控驱动云台,结合K230开发板的视觉识别能力,构建了一套完整的视觉巡线云台系统,实现了自动巡线与精准瞄准功能。文章深入剖析了硬件选型、双闭环PID控制算法、视觉识别与目标跟踪等核心技术,并分享了系统调试与避坑经验。

weixin_42596011的博客 676

java数组Arrays/ArrayUtils工具类常见操作

commons-lang包 org.apache.commons.lang.ArrayUtils类,有许多针对数组的操作,下面我们挑一些常用的方法示例。注意此时不能使用基本类型int, long, double这种,需要转换成相应的包装类。传入一个Comparator接口的实现类REVERSE_ORDER,即可实现逆序排列。注意sort方法是对数组原地排序,并不会返回一个新数组,返回类型为void。jdk中自带的Arrays工具类可以实现对数组排序功能。如果要逆序排,可以按如下操作。

bitcarmanlee的博客 964

全自动数据分析 - Claude Code Sub-Agents:自动化数据分析工厂

别忘了!claude code也是agent框架,类似langgraph,crewAI,autogen等等agent框架。我改造claude code搞一个数据分析智能体AI。试试看行不行!:让数据分析变得像聊天一样简单!

liangdabiao的博客 1072

第三方系统(异构系统)基于token身份认证方式访问Ecology9的Restful接口Ecology9服务器配置部分

通过Token的认证方式调用Ecology9系统Restful业务接口服务器配置部分

svsou的专栏 2178

Java数组详解3:Arrays 类(工具类)

Java数组详解3:Arrays 类(工具类)

sunyusong666的博客 900

Unreal5从入门到精通之如何录制360°VR全景视频

摘要:本文详细介绍了使用虚幻引擎(UE)生成360°全景视频的完整流程。首先需启用MovieRender Queue和Panoramic Capture插件,准备场景并设置相机序列。通过影片渲染队列选择8K分辨率输出PNG序列帧,利用ffmpeg工具转换为MP4格式,最终获得高精度全景视频。该方法适用于VR内容开发,能以较低性能消耗实现影院级画质,特别适合冥想类应用场景。教程涵盖从插件配置到后期合成的全链路操作,为开发者提供高效的全景内容生产解决方案。(150字)

TxNet 1404

Java基础——Arrays工具类详解

JDK 中提供了一个专门用于操作数组的工具类,即Arrays 类,位于java.util 包中。该类提供了一些列方法来操作数组,如排序、复制、比较、填充等,用户直接调用这些方法即可不需要自己编码实现,降低了开发难度。java.util.Arrays 是一个与数组相关的工具类,里面提供了大量静态方法,用来事项数组常见的操作。

weixin_70890083的博客 1758

华为OD机考双机位C卷 - 斗地主之顺子 (Java & Python& JS & C/C++ & GO )

华为OD机考双机位C卷 - 斗地主之顺子(OD上机考试双机位C卷)。提供在线OJ刷题。Java、C++、Python、GO语言、C语言、JavaScript题解,并提供完整思路讲解。

算法大师! 9695

【CAD二次开发】炸开所有的嵌套块

代码】【CAD二次开发】炸开所有的嵌套块。

1515

java数组之数组工具类——Arrays的使用

介绍数组常用的工具类中的方法,已经常见的关于数组的异常。

weixin_44554794的博客 1788

AUTOSAR进阶图解==>AUTOSAR_EXP_VFB

AUTOSAR虚拟功能总线(VFB)摘要 AUTOSAR虚拟功能总线(VFB)是汽车开放系统架构中的核心抽象概念,为分布式电子系统提供统一通信模型。VFB允许软件组件在不了解底层物理通信机制的情况下交互,通过运行时环境(RTE)实现组件间的数据交换。系统配置过程将抽象的VFB视图转换为具体实现,包括组件到ECU的映射和通信机制选择。VFB采用"last-is-best"语义进行数据通信,并支持模式管理机制,使组件能根据系统状态调整行为。此外,VFB还支持与非AUTOSAR系统的交互,通常

一名留德华的,康德的信徒的,专注于汽车电子领域的博客 1119

java中数组及Arrays、ArrayUtils工具类的相关操作

java中数组及Arrays、ArrayUtils工具类的相关操作 // (1) 创建一维数组, 三种创建方式 int[] iarr=new int[20]; String[] sarr={"a","b","c","d"}; double[] darr=new double[]{1.0,3.0,2.0}; Integer[] Iarr={1,2,3,4}; // (2) 创建二维数组: 维度固定与可变维度

晃^-^荡 700

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

java 创建数组工具类_数组工具类 (集合,Array的增、删、改、查等操作)

[java]代码库package org.loon.framework.db.test.util;import java.io.Serializable;import java.lang.reflect.Array;import java.util.Arrays;import java.util.Collection;import java.util.List;import java.util.R...

weixin_28790465的博客 666

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Java中数组以及操作数组的工具类Arrays

本文介绍了Java中数组的基本概念和关键操作。数组是固定长度、同类型元素的连续存储结构,通过索引访问。重点讲解了数组的声明与初始化方式(动态/静态初始化),以及多维数组的使用。文章详细说明了数组的常见操作(获取长度、遍历)和异常(越界、空指针),并介绍了Arrays工具类的重要功能:数组转字符串、排序、二分查找、填充、比较和复制等。最后强调了操作自定义类对象数组时的注意事项,如需要重写toString()方法、浅拷贝问题以及排序时必须提供比较规则等。

freed_Day的博客 526

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

JAVA操作数组的工具类,java操作数组的工具类-Arrays

static int binarySearch(type[] a, type key) 使用二分搜索法来搜索key元素在数组中的索引;若a数组不包括key,返回负数。(该方法必须已按升序排列后调用)。static int binarySearch(type[] a, int fromIndex, int toIndex, type key) 使用二分搜索法来搜索key元素在数组中从fromInde...

weixin_42392438的博客 162

java数组工具类_java操作数组的工具类-Arrays

static int binarySearch(type[] a, type key) 使用二分搜索法来搜索key元素在数组中的索引;若a数组不包括key,返回负数。(该方法必须已按升序排列后调用)。static int binarySearch(type[] a, int fromIndex, int toIndex, type key) 使用二分搜索法来搜索key元素在数组中从fromInde...

weixin_42311301的博客 160

Java-Arrays工具类:基础到进阶的数组操作全面指南

Arrays工具类提供了丰富的方法来操作数组,包括排序、搜索、填充、复制、比较等。掌握这些方法可以大大提高数组操作的效率和代码的可读性。在实际开发中,根据具体需求选择合适的方法,可以让你的代码更加简洁、高效, 希望本文的内容对你理解和使用Arrays工具类有所帮助。

aa_hdkf_vg的博客 804

[java]数组操作工具类

数组操作工具类 // 遍历 // 返回最大 // 查询指定索引的值 // 参数 arr // 参数 value // 返回值 public class ArrayTool{ //遍历 public static void getArray(int arr[]){ for(int x=0;x<arr.length;x++){

毛台 465

java 数组操作工具,Arrays是专门用于操作数组的工具类

排序或者查找数组里面的内容多值传递集合转数组数组转集合数组转字符串/*Arrays 是用于操作数组的工具类,里面全是静态的,和Collections是用来操作集合的工具类是不一样的当import导入的没有说明static,那么就说明是导入包中的所有类,如果说明是static的时候就说明导入的是某个类的所有静态成员,记得要加上static的说明符号。import static java.lang.S...

weixin_30827827的博客 223

java 自带的数组辅助类_day18_自行封装数组操作的工具类_JAVA自带数组工具类Arrays...

image.png封装的工具类//表示数组的工具类,涵盖了很多操作数组的方法class ArrayUtil{//交换元素static void swap(int[] arr,int index1,int index2){int temp = arr[index1];arr[index1] = arr[index2];arr[index2] = temp;}//获取数组中最大元素static int...

weixin_29712031的博客 207

Java Arrays工具类完全指南:数组操作的艺术

Java中的Arrays类(java.util.Arrays)是处理数组的核心工具类,提供排序、搜索、比较、填充、复制等丰富功能。主要特点包括:所有方法均为静态方法,支持基本类型和对象数组操作,包含null处理机制。核心功能涵盖数组排序(sort/parallelSort)、二分查找(binarySearch)、内容比较(equals/deepEquals)、填充(fill)、复制(copyOf/copyOfRange)、数组转列表(asList)、字符串转换(toString/deepToString)等

weixin_51786043的博客 1058

【转】Java工具类——数组操作ArrayUtil

package com.luang.util.common; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Random; import java.util.TreeMap; /** * * Array

小李专栏 8368

java.util.Arrays 操作数组工具类 及数组常见异常

java.util.Arrays 操作数组工具类 package com.atguigu.exer; import java.util.Arrays; /* *java.util.Arrays :操作数组的工具类。里面定义了很多操作数组的方法。 * */ public class ArraysTest { public static void main(String[] args) { //1.boolean equals(int [] a , int [] b):判断两个数组是否相等.

LeungKiChen 255

java int数组转double数组_Java_int、double型数组常用操作工具类(分享)

public class ArrayUtils {//求数组的最大值(int)public static int getMax(int[] arr){int max = arr[0];for(int i = 0;iif(maxmax = arr[i];}}return max;}//求数组的最小值(int)public static int getMin(int[] arr){int min = ...

weixin_39667041的博客 1043
上一篇: html表单输入框css样式美化特效源代码下载
下一篇: java图片裁剪处理工具类代码
springmvc_springdata
博客等级 码龄12年 197粉丝 389原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值