Javaでジェネリック配列を作成する方法は？

Javaジェネリックの実装のため、次のようなコードは使用できません。

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

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

タイプセーフを維持しながらこれをどのように実装できますか？

Javaフォーラムで次のような解決策を見ました。

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;
}

しかし、私は本当に何が起こっているのかわかりません。

私は見返りに質問をしなければなりGenSetません。「チェック済み」か「チェックなし」ですか。どういう意味ですか？

• チェック済み：強い型付け。GenSetに含まれているオブジェクトのタイプを明示的に認識している（つまり、コンストラクタがClass<E>引数で明示的に呼び出されたため、メソッドにタイプではない引数が渡されると例外がスローされますE。を参照してくださいCollections.checkedCollection。

  ->その場合、次のように記述します。

  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];
      }
  }

• オフ：弱い型付け。引数として渡されたオブジェクトの型チェックは実際には行われません。

  ->その場合、あなたは書くべきです

  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;
      }
  }

  配列のコンポーネントタイプは消去でなければならないことに注意してください typeパラメータのでください。

  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];
      }
  
      ...
  }

これらはすべて、Javaのジェネリックの既知の意図的な弱点に起因します。これは消去を使用して実装されたため、「ジェネリック」クラスは実行時に作成された型引数がわからないため、型を提供できません-明示的なメカニズム（型チェック）が実装されていない限り、安全性。

あなたはこれを行うことができます：

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

これは、Effective Javaでジェネリックコレクションを実装するための推奨方法の1つです。アイテム26。型エラーはなく、配列を繰り返しキャストする必要はありません。 ただし、これは潜在的に危険であるため警告をトリガーし、注意して使用する必要があります。コメントで詳しく説明されているように、これObject[]はE[]タイプになりすましており、ClassCastException安全に使用しないと予期しないエラーやsを引き起こす可能性があります。

経験則として、この動作は、キャスト配列が内部で（たとえば、データ構造をサポートするために）使用され、クライアントコードに返されたり公開されたりしない限り安全です。ジェネリック型の配列を他のコードに返す必要がある場合は、リフレクションArrayクラスが適切な方法です。

Listジェネリックを使用している場合は、可能な限り、配列ではなくを使用するほうがはるかに楽しい時間があることを言及する価値があります。確かにときどき選択の余地はありませんが、コレクションフレームワークを使用する方がはるかに堅牢です。

ここでは、ジェネリックを使用して、型の安全性を維持しながら、探している型の配列を正確に取得する方法を示します（他の回答では、Object配列が返されるか、コンパイル時に警告が表示されます）。

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];  
    }  
}

これは警告なしでコンパイルされmain、でわかるように、GenSetasのインスタンスを宣言するすべての型について、aその型の配列に割り当て、aその型の変数にから要素を割り当てることができます。つまり、配列配列の値は正しいタイプです。

これは、Javaチュートリアルで説明されているように、クラスリテラルをランタイムタイプトークンとして使用することで機能します。クラスリテラルは、コンパイラによってのインスタンスとして扱われますjava.lang.Class。使用するには、クラス名の後にを付け.classます。したがって、クラスを表すオブジェクトString.classとして機能しClassますString。これは、インターフェイス、列挙型、任意の次元の配列（例String[].class）、プリミティブ（例int.class）、およびキーワードvoid（例）でも機能しますvoid.class。

Classそれ自体は総称です（として宣言されClass<T>、TはClassオブジェクトが表す型を表します）。つまり、の型はString.classですClass<String>。

したがって、のコンストラクターを呼び出すときは常にGenSet、GenSetインスタンスの宣言された型の配列を表す最初の引数にクラスリテラルを渡します（たとえばString[].class、GenSet<String>）。プリミティブは型変数に使用できないため、プリミティブの配列を取得できないことに注意してください。

コンストラクター内でメソッドを呼び出すと、cast渡されたObject引数Classが、メソッドが呼び出されたオブジェクトによって表されるクラスにキャストされます。静的メソッドnewInstanceを呼び出すと、最初の引数として渡されたオブジェクトによって表される型の配列と、2番目の引数として渡されたオブジェクトによって指定された長さの配列java.lang.reflect.Arrayとして返されます。メソッドを呼び出す返しで表される配列のコンポーネントタイプを表すオブジェクトのオブジェクトは、例えば、（どのメソッドが呼び出されたため、場合にObjectClassintgetComponentTypeClassClassString.classString[].classnullClassオブジェクトが配列を表していません）。

最後の文は完全に正確ではありません。呼び出すと、クラスを表すオブジェクトString[].class.getComponentType()が返されますが、その型はではなくです。そのため、次のようなことはできません。ClassStringClass<?>Class<String>

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

オブジェクトClassを返すすべてのメソッドについても同様Classです。

この回答に対する Joachim Sauerのコメントについて（私は自分でコメントするのに十分な評判がありません）、キャストを使用する例T[]では、コンパイラーが型の安全性を保証できないため、警告が表示されます。

Ingoのコメントに関する編集：

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

これはタイプセーフな唯一の答えです

E[] a;

a = newArray(size);

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

より多くの次元に拡張するには、に[]次元パラメータを追加するだけですnewInstance()（Tisは型パラメータ、clsis Class<T>、d1through d5は整数）：

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);

詳細Array.newInstance()については、を参照してください。

Java 8では、ラムダまたはメソッド参照を使用して、一種の汎用配列を作成できます。これはリフレクティブアプローチ（を渡すClass）に似ていますが、ここではリフレクションを使用していません。

@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);
    }
}

たとえば、これはによって使用され<A> A[] Stream.toArray(IntFunction<A[]>)ます。

これは、 Java 8より前の匿名クラスを使用して行うこともできますが、より面倒です。

これは、Effective Java、2nd Editionの第5章（Generics）の項目25 ...で説明されています。配列を優先する

コードは機能しますが、チェックされていない警告が生成されます（次の注釈で抑制できます：

@SuppressWarnings({"unchecked"})

ただし、配列の代わりにリストを使用する方が良いでしょう。

このバグ/機能に関する興味深い議論がOpenJDKプロジェクトサイトにあります。

Class引数をコンストラクタに渡す必要はありません。これを試して。

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 + "]";
    }
}

そして

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

結果：

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

Javaジェネリックは、コンパイル時に型をチェックし、適切なキャストを挿入することで機能しますが、コンパイル済みファイルの型を消去します。これにより、ジェネリックを理解しないコード（意図的な設計上の決定でした）でジェネリックライブラリを使用できるようになりますが、通常、実行時に型が何であるかを確認できません。

パブリックStack(Class<T> clazz,int capacity)コンストラクタは、クラスの情報が意味し、実行時にクラスのオブジェクトを渡す必要がありますされ、それを必要とするコードの実行時に利用できます。そしてそのClass<T>形式は、コンパイラが、渡したClassオブジェクトがT型のClassオブジェクトであることを確認することを意味します。Tのサブクラスではなく、Tのスーパークラスではなく、正確にTです。

これは、コンストラクターで適切な型の配列オブジェクトを作成できることを意味します。つまり、コレクションに格納するオブジェクトの型は、コレクションに追加された時点で型がチェックされます。

こんにちはスレッドは死んでいますが、これに注意を向けたいと思います：

Genericsは、コンパイル時の型チェックに使用されます。

• したがって、目的は、入ってくるものが必要なものであることを確認することです。
• あなたが返すものは、消費者が必要とするものです。
• これをチェックして：

ジェネリッククラスを作成するときに、型キャストの警告について心配する必要はありません。使用時の心配です。

このソリューションはどうですか？

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

それは機能し、単純すぎて本当ではないように見えます。欠点はありますか？

このコードも見てください：

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;
}

任意の種類のオブジェクトのリストを同じタイプの配列に変換します。

私はすばやく簡単に機能する方法を見つけました。これはJava JDK 8でのみ使用していることに注意してください。以前のバージョンで動作するかどうかはわかりません。

特定の型パラメーターのジェネリック配列をインスタンス化することはできませんが、作成済みの配列をジェネリッククラスコンストラクターに渡すことができます。

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

    // ...

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

    // Do whatever with the array...
}

これで、メインで次のように配列を作成できます。

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

        // ...

    }
}

配列の柔軟性を高めるには、リンクリストを使用できます。ArrayListおよびJava.util.ArrayListクラスにあるその他のメソッド。

この例では、Javaリフレクションを使用して配列を作成しています。タイプセーフではないため、これを行うことは一般に推奨されません。代わりに、内部リストを使用して、配列をまったく回避する必要があります。

値のリストを渡す...

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

このコードスニペットを作成して、簡単な自動テストユーティリティに渡されるクラスを反射的にインスタンス化しました。

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});
}

このセグメントに注意してください：

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

アレイは、ここで開始するArray.newInstance（アレイのクラス、アレイのサイズ）。クラスは、プリミティブ（int.class）とオブジェクト（Integer.class）の両方にすることができます。

BeanUtilsはSpringの一部です。

実際にこれを行うには、次の例のようにオブジェクトの配列を作成し、それを目的の型にキャストするのがより簡単です。

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

ここで、SIZE定数であり、Tタイプ識別子であります

他の人から提案された強制キャストは私には効かず、違法キャストの例外を投げました。

ただし、この暗黙のキャストは正常に機能しました。

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

ここで、Itemは、メンバーを含む私が定義したクラスです。

private K value;

このようにして、K型の配列（項目に値しかない場合）またはクラスItemで定義したい任意のジェネリック型を取得します。

あなたが投稿した例で何が起こっているのかという質問に誰も答えていません。

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;
}

他の人が言ったように、ジェネリックはコンパイル中に「消去」されます。したがって、実行時にジェネリックのインスタンスは、そのコンポーネントタイプが何であるかを知りません。この理由は歴史的なものであり、Sunは既存のインターフェース（ソースとバイナリの両方）を壊すことなくジェネリックを追加したいと考えていました。

一方、配列は、実行時にそのコンポーネントのタイプを知っています。

この例では、コンストラクター（型を知っている）を呼び出すコードに、必要な型をクラスに通知するパラメーターを渡すことで、問題を回避しています。

したがって、アプリケーションは次のようなクラスを構築します

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

コンストラクターはコンポーネントのタイプを（実行時に）認識し、その情報を使用してリフレクションAPIを通じて配列を構築できます。

Array.newInstance(clazz, capacity);

最後に、型キャストがあります。コンパイラが返す配列Array#newInstance()が正しい型であることを知っているからです（わかっていても）。

このスタイルは少し見苦しいですが、何らかの理由で配列を作成したり、コンポーネントタイプのインスタンスを作成したりするなど、実行時にコンポーネントタイプを知る必要があるジェネリックタイプを作成する場合、最も悪い解決策になることがあります。

私はこの問題の一種の回避策を見つけました。

以下の行は一般的な配列作成エラーをスローします

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

ただしList<Person>、別のクラスにカプセル化しても機能します。

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


public class PersonList {

    List<Person> people;

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

getterを使用して、PersonListクラスの人々を公開できます。以下の行は、List<Person>すべての要素にがある配列を提供します。つまり、の配列ですList<Person>。

PersonList[] personLists=new PersonList[10];

私が取り組んでいるいくつかのコードでこのようなものが必要でした、そしてこれはそれを機能させるために私がやったことです。これまでのところ問題はありません。

Object配列を作成して、どこでもEにキャストできます。うん、それはそれを行うにはあまりきれいな方法ではありませんが、それは少なくともうまくいくはずです。

これを試して。

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>();
        }
    }
}

これに対する簡単で厄介な回避策は、メインクラス内に2つ目の「ホルダー」クラスをネストし、それを使用してデータを保持することです。

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

この質問とは関係ないかもしれませんが、使用中に「generic array creation」エラーが発生しました

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

私は以下の作品を見つけました（そして私のために働いた） @SuppressWarnings({"unchecked"})：

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

このコードが効果的なジェネリック配列を作成するかどうか疑問に思っていますか？

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;
}

編集：おそらく、そのような配列を作成する別の方法は、必要なサイズがわかっていて小さい場合、必要な数の「null」をzeroArrayコマンドに単純にフィードすることでしょうか？

もちろん、これはcreateArrayコードを使用する場合ほど用途が広いわけではありません。

あなたはキャストを使うことができます：

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

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

私は実際に、ジェネリックアレイを開始できないことを回避するかなりユニークなソリューションを見つけました。あなたがしなければならないことは、次のようにジェネリック変数Tを受け取るクラスを作成することです：

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

そして、あなたの配列クラスでそれを次のように始めてください：

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

を開始するnew Generic Invoker[]と、チェックされていない状態で問題が発生しますが、実際には問題はありません。

配列から取得するには、次のようにarray [i] .variableを呼び出す必要があります。

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

配列のサイズ変更などの残りは、次のようにArrays.copyOf（）で実行できます。

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

そしてadd関数は次のように追加できます：

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++;
}

vnportnoyによると、構文

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

次のように入力されるnull参照の配列を作成します

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

これはタイプセーフです。

private E a[];
private int size;

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

ジェネリック配列の作成はJavaでは許可されていませんが、次のようにできます

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