Bagaimana cara membuat array generik di Java?

Karena penerapan generik Java, Anda tidak dapat memiliki kode seperti ini:

public class GenSet<E> {
    private E a[];

    public GenSet() {
        a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
    }
}

Bagaimana saya bisa menerapkan ini sambil menjaga keamanan jenis?

Saya melihat solusi di forum Java yang berjalan seperti ini:

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Tetapi saya benar-benar tidak mengerti apa yang sedang terjadi.

Sebagai gantinya, saya harus mengajukan pertanyaan: apakah GenSet"dicentang" atau "tidak dicentang"? Apa artinya?

• Diperiksa : ketikan yang kuat . GenSettahu secara eksplisit jenis objek yang dikandungnya (yaitu konstruktornya secara eksplisit dipanggil dengan Class<E>argumen, dan metode akan mengeluarkan pengecualian ketika mereka memberikan argumen yang bukan tipe E. Lihat Collections.checkedCollection.

  -> dalam hal ini, Anda harus menulis:

  public class GenSet<E> {
  
      private E[] a;
  
      public GenSet(Class<E> c, int s) {
          // Use Array native method to create array
          // of a type only known at run time
          @SuppressWarnings("unchecked")
          final E[] a = (E[]) Array.newInstance(c, s);
          this.a = a;
      }
  
      E get(int i) {
          return a[i];
      }
  }
  

• Tidak dicentang : pengetikan lemah . Tidak ada pemeriksaan tipe yang benar-benar dilakukan pada objek yang dilewatkan sebagai argumen.

  -> dalam hal ini, Anda harus menulis

  public class GenSet<E> {
  
      private Object[] a;
  
      public GenSet(int s) {
          a = new Object[s];
      }
  
      E get(int i) {
          @SuppressWarnings("unchecked")
          final E e = (E) a[i];
          return e;
      }
  }
  

  Perhatikan bahwa tipe komponen array harus menjadi penghapusan parameter tipe:

  public class GenSet<E extends Foo> { // E has an upper bound of Foo
  
      private Foo[] a; // E erases to Foo, so use Foo[]
  
      public GenSet(int s) {
          a = new Foo[s];
      }
  
      ...
  }
  

Semua ini merupakan hasil dari kelemahan generik yang diketahui dan disengaja di Jawa: ini diimplementasikan dengan menggunakan penghapusan, jadi kelas "generik" tidak tahu argumen tipe apa yang mereka buat pada saat run time, dan oleh karena itu tidak dapat memberikan tipe- keamanan kecuali jika beberapa mekanisme eksplisit (pengecekan tipe) diimplementasikan.

Kamu bisa melakukan ini:

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

Ini adalah salah satu cara yang disarankan untuk mengimplementasikan koleksi generik di Java yang Efektif; Butir 26 . Tidak ada kesalahan jenis, tidak perlu melemparkan array berulang kali. Namun ini memicu peringatan karena berpotensi berbahaya, dan harus digunakan dengan hati-hati. Sebagaimana dirinci dalam komentar, ini Object[]sekarang menyamar sebagai E[]tipe kami , dan dapat menyebabkan kesalahan tak terduga ClassCastExceptionjika digunakan secara tidak aman.

Sebagai aturan praktis, perilaku ini aman selama array cor digunakan secara internal (misalnya untuk mendukung struktur data), dan tidak dikembalikan atau diekspos ke kode klien. Jika Anda perlu mengembalikan larik tipe generik ke kode lain, Arraykelas refleksi yang Anda sebutkan adalah cara yang tepat.

Layak disebutkan bahwa jika memungkinkan, Anda akan memiliki waktu yang jauh lebih bahagia bekerja dengan Lists daripada array jika Anda menggunakan obat generik. Tentu saja kadang-kadang Anda tidak punya pilihan, tetapi menggunakan kerangka koleksi jauh lebih kuat.

Berikut ini cara menggunakan obat generik untuk mendapatkan larik tipe tepat yang Anda cari sambil menjaga keamanan tipe (berbeda dengan jawaban lain, yang akan mengembalikan Objectarray atau menghasilkan peringatan pada waktu kompilasi):

import java.lang.reflect.Array;  

public class GenSet<E> {  
    private E[] a;  

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

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

Itu mengkompilasi tanpa peringatan, dan seperti yang Anda lihat main, untuk tipe apa pun yang Anda nyatakan instance GenSetas, Anda bisa menetapkan ake array tipe itu, dan Anda bisa menetapkan elemen dari ake variabel tipe itu, artinya array itu dan nilai-nilai dalam array adalah tipe yang benar.

Ia bekerja dengan menggunakan literal kelas sebagai token jenis runtime, seperti yang dibahas dalam Tutorial Java . Literal kelas diperlakukan oleh kompiler sebagai instance dari java.lang.Class. Untuk menggunakannya, cukup ikuti nama kelas dengan .class. Jadi, String.classbertindak sebagai Classobjek yang mewakili kelas String. Ini juga berfungsi untuk antarmuka, enum, array dimensi apa pun (misalnya String[].class), primitif (mis. int.class), Dan kata kunci void(yaitu void.class).

Classitu sendiri generik (dideklarasikan sebagai Class<T>, di mana Tsingkatan dari tipe yang Classdiwakili objek), artinya tipe String.classis Class<String>.

Jadi, setiap kali Anda memanggil konstruktor GenSet, Anda meneruskan literal kelas untuk argumen pertama yang mewakili array dari tipe GenSetinstance yang dinyatakan (misalnya String[].classuntuk GenSet<String>). Perhatikan bahwa Anda tidak akan bisa mendapatkan array primitif, karena primitif tidak dapat digunakan untuk variabel tipe.

Di dalam konstruktor, memanggil metode castmengembalikan Objectargumen yang dilewatkan ke kelas yang diwakili oleh Classobjek tempat metode dipanggil. Memanggil metode statis newInstancedalam java.lang.reflect.Arraypengembalian sebagai Objectarray dari tipe yang diwakili oleh Classobjek yang dilewati sebagai argumen pertama dan panjang yang ditentukan oleh yang intdilewati sebagai argumen kedua. Memanggil metode getComponentTypemengembalikan Classobjek yang mewakili jenis komponen array yang diwakili oleh Classobjek tempat metode dipanggil (misalnya String.classuntuk String[].class, nulljika Classobjek tidak mewakili array).

Kalimat terakhir itu tidak sepenuhnya akurat. Memanggil String[].class.getComponentType()mengembalikan Classobjek yang mewakili kelas String, tetapi tipenya adalah Class<?>, bukan Class<String>, itulah sebabnya Anda tidak bisa melakukan sesuatu seperti berikut ini.

String foo = String[].class.getComponentType().cast("bar"); // won't compile

Hal yang sama berlaku untuk setiap metode Classyang mengembalikan Classobjek.

Mengenai komentar Joachim Sauer tentang jawaban ini (saya sendiri tidak memiliki cukup reputasi untuk mengomentarinya), contoh menggunakan pemeran T[]akan menghasilkan peringatan karena kompiler tidak dapat menjamin keamanan jenis dalam kasus itu.

Edit tentang komentar Ingo:

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

Ini adalah satu-satunya jawaban yang aman jenis

E[] a;

a = newArray(size);

@SafeVarargs
static <E> E[] newArray(int length, E... array)
{
    return Arrays.copyOf(array, length);
}

Untuk memperluas ke dimensi yang lebih, cukup tambahkan []parameter 's dan dimensi ke newInstance()( Tadalah parameter tipe, clsadalah a Class<T>, d1through d5adalah bilangan bulat):

T[] array = (T[])Array.newInstance(cls, d1);
T[][] array = (T[][])Array.newInstance(cls, d1, d2);
T[][][] array = (T[][][])Array.newInstance(cls, d1, d2, d3);
T[][][][] array = (T[][][][])Array.newInstance(cls, d1, d2, d3, d4);
T[][][][][] array = (T[][][][][])Array.newInstance(cls, d1, d2, d3, d4, d5);

Lihat Array.newInstance()detailnya.

Di Java 8, kita bisa melakukan semacam pembuatan array generik menggunakan lambda atau referensi metode. Ini mirip dengan pendekatan reflektif (yang melewati a Class), tetapi di sini kita tidak menggunakan refleksi.

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

Sebagai contoh, ini digunakan oleh <A> A[] Stream.toArray(IntFunction<A[]>).

Ini bisa juga dilakukan pre-Jawa 8 menggunakan kelas anonim tapi lebih rumit.

Ini dicakup dalam Bab 5 (Generik) dari Java Efektif, Edisi ke-2 , item 25 ... Memilih daftar ke array

Kode Anda akan berfungsi, meskipun akan menghasilkan peringatan yang tidak dicentang (yang dapat Anda tekan dengan anotasi berikut:

@SuppressWarnings({"unchecked"})

Namun, mungkin akan lebih baik menggunakan Daftar daripada Array.

Ada diskusi menarik tentang bug / fitur ini di situs proyek OpenJDK .

Anda tidak perlu meneruskan argumen Kelas ke konstruktor. Coba ini.

public class GenSet<T> {
    private final T[] array;
    @SuppressWarnings("unchecked")
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        Class<?> c = dummy.getClass().getComponentType();
        array = (T[])Array.newInstance(c, capacity);
    }
    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

dan

GenSet<Integer> intSet = new GenSet<>(3);
System.out.println(intSet);
System.out.println(new GenSet<String>(2));

hasil:

GenSet of java.lang.Integer[3]
GenSet of java.lang.String[2]

Java generics bekerja dengan memeriksa jenis pada waktu kompilasi dan memasukkan gips yang sesuai, tetapi menghapus jenis-jenis tersebut di file yang dikompilasi. Ini membuat pustaka generik dapat digunakan oleh kode yang tidak memahami generik (yang merupakan keputusan desain yang disengaja) tetapi yang berarti Anda biasanya tidak bisa mengetahui apa jenisnya saat dijalankan.

Masyarakat Stack(Class<T> clazz,int capacity)konstruktor mengharuskan Anda untuk melewati sebuah objek Kelas pada waktu berjalan, mana informasi berarti kelas yang tersedia saat runtime ke kode yang membutuhkannya. Dan Class<T>bentuk itu berarti bahwa kompiler akan memeriksa bahwa objek Kelas yang Anda lewati adalah objek Kelas yang tepat untuk tipe T. Bukan subkelas T, bukan superclass T, tetapi tepatnya T.

Ini kemudian berarti bahwa Anda dapat membuat objek array dari tipe yang sesuai di konstruktor Anda, yang berarti bahwa jenis objek yang Anda simpan di koleksi Anda akan diperiksa tipenya pada titik mereka ditambahkan ke koleksi.

Hai meskipun utasnya sudah mati, saya ingin menarik perhatian Anda pada ini:

Generik digunakan untuk memeriksa tipe selama waktu kompilasi:

• Karena itu tujuannya adalah untuk memeriksa apa yang masuk adalah yang Anda butuhkan.
• Apa yang Anda kembalikan adalah apa yang dibutuhkan konsumen.
• Periksa ini:

Jangan khawatir tentang peringatan typecasting ketika Anda menulis kelas generik. Khawatir saat Anda menggunakannya.

Bagaimana dengan solusi ini?

@SafeVarargs
public static <T> T[] toGenericArray(T ... elems) {
    return elems;
}

Ini bekerja dan terlihat terlalu sederhana untuk menjadi kenyataan. Apakah ada kekurangan?

Lihat juga kode ini:

public static <T> T[] toArray(final List<T> obj) {
    if (obj == null || obj.isEmpty()) {
        return null;
    }
    final T t = obj.get(0);
    final T[] res = (T[]) Array.newInstance(t.getClass(), obj.size());
    for (int i = 0; i < obj.size(); i++) {
        res[i] = obj.get(i);
    }
    return res;
}

Itu mengkonversi daftar jenis objek ke array dari jenis yang sama.

Saya telah menemukan cara cepat dan mudah yang berfungsi untuk saya. Perhatikan bahwa saya hanya menggunakan ini pada Java JDK 8. Saya tidak tahu apakah ini akan bekerja dengan versi sebelumnya.

Meskipun kami tidak dapat membuat instance array generik dari parameter tipe tertentu, kami dapat meneruskan array yang sudah dibuat ke konstruktor kelas generik.

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

Sekarang di main kita bisa membuat array seperti ini:

class GenArrayDemo {
    public static void main(String[] args) {
        int size = 10; // array size
        // Here we can instantiate the array of the type we want, say Character (no primitive types allowed in generics)
        Character[] ar = new Character[size];

        GenArray<Character> = new Character<>(ar); // create the generic Array

        // ...

    }
}

Untuk lebih fleksibel dengan array Anda, Anda dapat menggunakan daftar tertaut misalnya. ArrayList dan metode lain yang ditemukan di kelas Java.util.ArrayList.

Contohnya menggunakan refleksi Java untuk membuat array. Melakukan ini umumnya tidak dianjurkan, karena itu bukan typesafe. Sebagai gantinya, yang harus Anda lakukan hanyalah menggunakan Daftar internal, dan hindari array sama sekali.

Melewati daftar nilai ...

public <T> T[] array(T... values) {
    return values;
}

Saya membuat potongan kode ini untuk secara reflektif membuat instance kelas yang dilewatkan untuk utilitas tes otomatis sederhana.

Object attributeValue = null;
try {
    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }
    else if(!clazz.isInterface()){
        attributeValue = BeanUtils.instantiateClass(clazz);
    }
} catch (Exception e) {
    logger.debug("Cannot instanciate \"{}\"", new Object[]{clazz});
}

Perhatikan segmen ini:

    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }

untuk array yang memulai di mana Array.newInstance (kelas array, ukuran array) . Kelas dapat berupa primitif (int.class) dan objek (Integer.class).

BeanUtils adalah bagian dari Spring.

Sebenarnya cara yang lebih mudah untuk melakukannya, adalah membuat array objek dan melemparkannya ke tipe yang Anda inginkan seperti contoh berikut:

T[] array = (T[])new Object[SIZE];

di mana SIZEkonstanta dan Tpengenal tipe

Para pemeran paksa yang disarankan oleh orang lain tidak bekerja untuk saya, kecuali pengecoran ilegal.

Namun, pemeran implisit ini bekerja dengan baik:

Item<K>[] array = new Item[SIZE];

di mana Item adalah kelas yang saya definisikan mengandung anggota:

private K value;

Dengan cara ini Anda mendapatkan larik tipe K (jika item hanya memiliki nilai) atau tipe generik apa pun yang ingin Anda tetapkan dalam Item kelas.

Tidak ada orang lain yang menjawab pertanyaan tentang apa yang terjadi dalam contoh yang Anda posting.

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Seperti yang orang lain katakan generik "dihapus" selama kompilasi. Jadi pada saat runtime instance dari generik tidak tahu apa tipe komponennya. Alasan untuk ini adalah historis, Sun ingin menambahkan obat generik tanpa merusak antarmuka yang ada (baik sumber dan biner).

Array di sisi lain do tahu jenis komponen mereka pada saat runtime.

Contoh ini mengatasi masalah dengan meminta kode yang memanggil konstruktor (yang tahu tipe) melewati parameter yang memberi tahu kelas tipe yang diperlukan.

Jadi aplikasi akan membangun kelas dengan sesuatu seperti

Stack<foo> = new Stack<foo>(foo.class,50)

dan konstruktor sekarang tahu (saat runtime) apa tipe komponen itu dan dapat menggunakan informasi itu untuk membangun array melalui API refleksi.

Array.newInstance(clazz, capacity);

Akhirnya kita memiliki tipe cast karena kompiler tidak memiliki cara untuk mengetahui bahwa array yang dikembalikan oleh Array#newInstance()adalah tipe yang benar (walaupun kita tahu).

Gaya ini agak jelek tapi kadang-kadang bisa menjadi solusi paling buruk untuk membuat tipe generik yang perlu mengetahui tipe komponen mereka saat runtime untuk alasan apa pun (membuat array, atau membuat contoh dari jenis komponen mereka, dll.).

Saya menemukan semacam pekerjaan untuk masalah ini.

Baris di bawah ini menampilkan kesalahan pembuatan array generik

List<Person>[] personLists=new ArrayList<Person>()[10];

Namun jika saya merangkum List<Person>dalam kelas yang terpisah, itu berfungsi.

import java.util.ArrayList;
import java.util.List;


public class PersonList {

    List<Person> people;

    public PersonList()
    {
        people=new ArrayList<Person>();
    }
}

Anda dapat mengekspos orang-orang di kelas PersonList melalui pengambil. Baris di bawah ini akan memberi Anda sebuah array, yang memiliki List<Person>dalam setiap elemen. Dengan kata lain susunan List<Person>.

PersonList[] personLists=new PersonList[10];

Saya membutuhkan sesuatu seperti ini dalam beberapa kode yang sedang saya kerjakan dan inilah yang saya lakukan untuk membuatnya bekerja. Sejauh ini tidak ada masalah.

Anda bisa membuat array Obyek dan melemparkannya ke E di mana-mana. Ya, itu bukan cara yang sangat bersih untuk melakukannya tetapi setidaknya harus bekerja.

coba ini.

private int m = 0;
private int n = 0;
private Element<T>[][] elements = null;

public MatrixData(int m, int n)
{
    this.m = m;
    this.n = n;

    this.elements = new Element[m][n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            this.elements[i][j] = new Element<T>();
        }
    }
}

Sebuah solusi yang mudah, meskipun berantakan untuk ini adalah untuk bersarang kelas "pemegang" kedua di dalam kelas utama Anda, dan menggunakannya untuk menyimpan data Anda.

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

Mungkin tidak terkait dengan pertanyaan ini tetapi ketika saya mendapatkan " generic array creation" kesalahan untuk menggunakan

Tuple<Long,String>[] tupleArray = new Tuple<Long,String>[10];

Saya menemukan karya-karya berikut (dan bekerja untuk saya) dengan @SuppressWarnings({"unchecked"}):

 Tuple<Long, String>[] tupleArray = new Tuple[10];

Saya ingin tahu apakah kode ini akan membuat array generik yang efektif?

public T [] createArray(int desiredSize){
    ArrayList<T> builder = new ArrayList<T>();
    for(int x=0;x<desiredSize;x++){
        builder.add(null);
    }
    return builder.toArray(zeroArray());
}

//zeroArray should, in theory, create a zero-sized array of T
//when it is not given any parameters.

private T [] zeroArray(T... i){
    return i;
}

Sunting: Mungkin cara alternatif untuk membuat array seperti itu, jika ukuran yang Anda butuhkan diketahui dan kecil, akan dengan cukup memberi makan jumlah "null" yang diperlukan ke dalam perintah zeroArray?

Meskipun jelas ini tidak serbaguna seperti menggunakan kode createArray.

Anda bisa menggunakan gips:

public class GenSet<Item> {
    private Item[] a;

    public GenSet(int s) {
        a = (Item[]) new Object[s];
    }
}

Saya benar-benar menemukan solusi yang cukup unik untuk memotong ketidakmampuan untuk memulai array generik. Yang harus Anda lakukan adalah membuat kelas yang mengambil variabel T generik seperti:

class GenericInvoker <T> {
    T variable;
    public GenericInvoker(T variable){
        this.variable = variable;
    }
}

dan kemudian di kelas array Anda mulai saja seperti ini:

GenericInvoker<T>[] array;
public MyArray(){
    array = new GenericInvoker[];
}

memulai new Generic Invoker[]akan menyebabkan masalah dengan tidak dicentang tetapi seharusnya tidak ada masalah.

Untuk mendapatkan dari array, Anda harus memanggil array [i] .variable seperti:

public T get(int index){
    return array[index].variable;
}

Sisanya, seperti mengubah ukuran array dapat dilakukan dengan Arrays.copyOf () seperti:

public void resize(int newSize){
    array = Arrays.copyOf(array, newSize);
}

Dan fungsi add dapat ditambahkan seperti ini:

public boolean add(T element){
    // the variable size below is equal to how many times the add function has been called 
    // and is used to keep track of where to put the next variable in the array
    arrays[size] = new GenericInvoker(element);
    size++;
}

Menurut vnportnoy sintaks

GenSet<Integer> intSet[] = new GenSet[3];

membuat array referensi nol, untuk diisi sebagai

for (int i = 0; i < 3; i++)
{
   intSet[i] = new GenSet<Integer>();
}

yang merupakan tipe aman.

private E a[];
private int size;

public GenSet(int elem)
{
    size = elem;
    a = (E[]) new E[size];
}

Pembuatan array generik tidak diizinkan di java tetapi Anda dapat melakukannya seperti

class Stack<T> {
private final T[] array;
public Stack(int capacity) {
    array = (T[]) new Object[capacity];
 }
}