迹忆客 专注技术分享

数组可以定义为存储在连续内存位置的项目的集合。通用数组独立于任何数据类型，并且在运行时评估其信息类型。

但是，Java 不允许数组是泛型的，因为在 Java 中，数组包含与其组件相关的信息，并且在运行时使用此信息来分配内存。

我们可以使用 Java 中的对象数组和反射类特性模拟类似于数组的通用结构。我们将在下面讨论这些方法。

在 Java 中使用对象数组创建泛型数组

在这种方法中使用类型对象数组作为成员。我们使用 get() 和 set() 函数来读取和设置数组元素。

以下程序演示了如何使用对象数组来创建通用数组。

import java.util.Arrays;
 
class Generic_Array<E> {
    private final Object[] obj_array;   //object array
    public final int length;
    // class constructor
    public Generic_Array(int len)    {
        //new object array
        obj_array = new Object [len];
        this.len = len;
    }
    // get new object array(obj_array[i])
    E get(int j) {
        @SuppressWarnings("unchecked")
        final E e = (E)object_array[j];
        return e;
    }
    // set e at new object array(obj_array[i])
    void set(int j, E e) {
        object_array[j] = e;
    }
    @Override
    public String toString() {
        return Arrays.toString(object_array);
    }
}
class Main {
    public static void main(String[] args){
        final int len = 5;
        // creating an integer array 
        Generic_Array<Integer>int_Array = new Generic_Array(len);
        System.out.print("Generic Array <Integer>:" + " ");
        for (int i = 2; i < len; i++)
            int_Array.set(i, i * 2);
        System.out.println(int_Array);
        // creating a string array
        Generic_Array<String>str_Array = new Generic_Array(len);
        System.out.print("Generic Array <String>:" + " ");
        for (int i = 0; i < len; i++)
            str_Array.set(i, String.valueOf((char)(i + 97)));
        System.out.println(str_Array);
    }
}

输出：

Generic Array <Integer>: [2, 4, 6, 8, 10]
Generic Array <String>: [a, b, c, d, e]

在 Java 中使用反射类创建泛型数组

在这种类型的方法中，反射类用于创建一个泛型数组，其类型仅在运行时已知。

前一种方法和这种方法的唯一区别是反射类本身用作构造函数。之后，反射类通过将数据显式传递给构造函数类来初始化一个对象数组。

以下程序演示了如何使用反射来创建通用数组。

import java.util.Arrays; 
class Generic_Array<E> {
    private final E[] objArray;
    public final int length;
    //constructor class
    public Generic_Array(Class<E>dataType, int length){
        // creatting a new array with the specified data type and length at runtime using reflection method.
        this.objArray = (E[]) java.lang.reflect.Array.newInstance(dataType, len);
        this.len = len;
    }
    // get element at obj_Array[i]
    E get(int i) {
        return obj_Array[i];
    }
    // assign e to obj_Array[i]
    void set(int i, E e) {
        obj_Array[i] = e;
    }
    @Override
    public String toString() {
        return Arrays.toString(obj_Array);
    }
}
class Main {
    public static void main(String[] args){
        final int len = 5;
        // create array with Integer as data type
        Generic_Array<Integer>int_Array = new Generic_Array(Integer.class, len);
        System.out.print("Generic Array<Int>:" + " ");
        for (int i = 2; i < len; i++)
            int_Array.set(i, i + 10);
        System.out.println(int_Array);
        // create an array with String as data type
        Generic_Array<String>str_Array = new Generic_Array(String.class, len);
        System.out.print("Generic Array<Str>:" + " ");
        for (int i = 0; i < len; i++)
            str_Array.set(i, String.valueOf((char)(i + 65)));
        System.out.println(str_Array);
    }
}

输出：

Generic Array<Int>: [12, 13, 14, 15, 16]
Generic Array<Str>: [A, B, C, D, E]

泛型数组不能提供类型安全，除非实现了类型检查或显式机制，因为泛型类对于它们在运行时创建的那种类型的参数是未知的。

如果我们想使用泛型获得一个没有任何安全性的精确数组，可以如下所示完成。

import java.lang.reflect.Array;  

public class Gen_Set<E> {
    private E[] x;  

    public Gen_Set(Class<E[]> cla, int len) {
        x = cla.cast(Array.newInstance(cla.getComponentType(), len));  
    }  

    public static void main(String[] args) {
        Gen_Set<String> foo = new Gen_Set<String>(String[].class, 1);  
        String[] bar = foo.x;  
        foo.x[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

这段代码在编译时不会给出警告，我们可以看到，在主类中，声明的 Gen_Set 实例的类型可以分配给该类型的数组的 x，这意味着数组和数组的值是不正确的类型。