Java 中的通用陣列建立

Siddharth Swami 2023年1月30日 2021年6月29日
  1. 在 Java 中使用物件陣列建立泛型陣列
  2. 在 Java 中使用反射類建立泛型陣列
Java 中的通用陣列建立

陣列可以定義為儲存在連續記憶體位置的專案的集合。通用陣列獨立於任何資料型別,並且在執行時評估其資訊型別。

但是,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,這意味著陣列和陣列的值是不正確的型別。

相關文章 - Java Array