Java编写程序：Java编写程序：用泛型写数组的基本操作： 插入元素、删除元素，查找元素，返回第i个下标对应的元素。 2、扩展应用： ​数组元素倒置，数组元素分拆，数组元素合并

在Java中，使用泛型可以提供一种类型安全的方式来处理数组操作，这里我会简单介绍如何使用泛型实现基本数组操作以及一些扩展应用。

**1. 泛型数组的基本操作：**

public class ArrayUtils<T> {
    // 创建一个指定类型的动态大小数组
    public static T[] createArray(int size) {
        return (T[]) new Object[size];
    }

    // 插入元素
    public static <T> void insert(T[] array, int index, T element) {
        if (index >= array.length) throw new IndexOutOfBoundsException();
        System.arraycopy(array, index, array, index + 1, array.length - index);
        array[index] = element;
    }

    // 删除元素（假设元素存在）
    public static <T> void delete(T[] array, int index) {
        if (index < 0 || index >= array.length) throw new IndexOutOfBoundsException();
        System.arraycopy(array, index + 1, array, index, array.length - 1);
    }

    // 查找元素
    public static <T> boolean contains(T[] array, T target) {
        for (T element : array) {
            if (element.equals(target)) return true;
        }
        return false;
    }

    // 返回第i个元素
    public static <T> T get(T[] array, int i) {
        return array[i];
    }
}

**2. 扩展应用：**

- **数组元素倒置：**

public static <T> void reverseArray(T[] array) {
    int start = 0, end = array.length - 1;
    while (start < end) {
        swap(array, start, end);
        start++;
        end--;
    }
}

private static <T> void swap(T[] array, int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

- **数组元素分拆：**

public static <T> List<List<T>> splitArrayIntoChunks(T[] array, int chunkSize) {
    List<List<T>> chunks = new ArrayList<>();
    for (int i = 0; i <= array.length; i += chunkSize) {
        chunks.add(Arrays.asList(array, i, Math.min(i + chunkSize, array.length)));
    }
    return chunks.subList(0, Math.min(chunks.size(), array.length / chunkSize));
}

- **数组元素合并：**

public static <T> T[] mergeArrays(T[]... arrays) {
    int totalLength = 0;
    for (T[] array : arrays) totalLength += array.length;

    T[] mergedArray = Arrays.copyOf(new ArrayUtils().createArray(totalLength), totalLength);

    int offset = 0;
    for (T[] array : arrays) {
        System.arraycopy(array, 0, mergedArray, offset, array.length);
        offset += array.length;
    }
    return mergedArray;
}