Jak utworzyć tablicę generyczną w Javie?

Zawsze możesz to zrobić:

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

Jest to jeden z sugerowanych sposobów implementacji zbioru generycznego w efektywnej Javie; pozycja 26 . Brak błędów typu, nie ma potrzeby wielokrotnego rzucania tablicy. jednakże to powoduje Ostrzeżenie, ponieważ jest potencjalnie niebezpieczne i powinno być używane z ostrożnością. Jak szczegółowo opisano w komentarzach, ten Object[] jest teraz maskowany jako nasz typ E[] i może powodować nieoczekiwane błędy lub ClassCastException s, jeśli zostanie użyty niewłaściwie.

Jako zasada, to zachowanie jest bezpieczne, o ile tablica cast jest używana wewnętrznie (np. do tworzenia kopii zapasowych struktury danych) i nie jest zwracana ani wystawiana na działanie kodu klienta. Jeśli musisz zwrócić tablicę typu generycznego do innego kodu, Klasa reflection Array, o której wspominasz, jest właściwą drogą.

Warto wspomnieć, że jeśli to możliwe, będziesz miał dużo szczęśliwszy czas pracy z Lists, a nie tablicami, jeśli używasz leków generycznych. Z pewnością czasami nie masz wyboru, ale korzystając z struktura kolekcji jest znacznie bardziej wytrzymała.

Oto jak użyć generyków, aby uzyskać tablicę dokładnie tego typu, którego szukasz, zachowując bezpieczeństwo typów (w przeciwieństwie do innych odpowiedzi, które zwrócą tablicę Object lub spowodują ostrzeżenia podczas kompilacji):

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

, który kompiluje się bez ostrzeżeń i jak widać w main, dla dowolnego typu zadeklarowanego jako instancja GenSet, możesz przypisać a do tablicy tego typu, A element z a do zmiennej tego typu, co oznacza, że tablica i wartości w tablicy są odpowiedniego typu.

Działa poprzez użycie liter klas jako tokenów typu runtime, jak opisano w samouczkach Java. Literały klas są traktowane przez kompilator jako instancje java.lang.Class. Aby go użyć, po prostu wykonaj nazwę klasy za pomocą .class. Tak więc String.class działa jako Class obiekt reprezentujący klasę String. Działa to również dla interfejsów, enum, tablic dowolnych wymiarów (np. String[].class), prymitywów (np. int.class) i słowo kluczowe void (tj. void.class).

Class jest to typ ogólny (deklarowany jako Class<T>, gdzie {[19] } oznacza typ, który reprezentuje obiekt Class), co oznacza, że typ String.class to Class<String>.

Tak więc, za każdym razem, gdy wywołujesz konstruktor dla GenSet, przekazujesz w klasie literał dla pierwszego argumentu reprezentującego tablicę zadeklarowanego typu instancji GenSet (np. String[].class dla GenSet<String>). Zauważ, że nie będziesz w stanie uzyskać tablicy prymitywów, ponieważ prymitywy nie mogą być używane dla zmiennych typu.

Wewnątrz konstruktora wywołanie metody cast zwraca przekazany argument Object oddany do klasy reprezentowanej przez obiekt Class, w którym metoda została wywołana. Wywołanie metody statycznej newInstance w java.lang.reflect.Array zwraca jako Object tablicę typu reprezentowanego przez obiekt Class przekazany jako pierwszy argument i o długości określonej przez int przekazany jako drugi argument. Wywołanie metody getComponentType zwraca obiekt Class reprezentujący komponent typ tablicy reprezentowanej przez obiekt Class, na którym została wywołana metoda (np. String.class dla String[].class, null jeśli obiekt Class nie reprezentuje tablicy).

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

To samo dotyczy każdej metody w Class, która zwraca obiekt Class.

Odnośnie Komentarz Joachima Sauera do ta odpowiedź (Nie mam wystarczającej reputacji, aby sam ją skomentować), przykład użycia cast do T[] spowoduje Ostrzeżenie, ponieważ kompilator nie może zagwarantować bezpieczeństwa typu w tym przypadku.

Edytuj komentarze Ingo:

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

Jest to jedyna odpowiedź, która jest typu safe

E[] a;

a = newArray(size);

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

Aby rozszerzyć na więcej wymiarów, wystarczy dodać [] ' s i parametry wymiarów do newInstance() (T jest parametrem typu, cls jest Class<T>, d1 przez d5 są liczbami całkowitymi):

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

Zobacz Array.newInstance() Po szczegóły.

W Javie 8, możemy wykonać rodzaj generycznego tworzenia tablic przy użyciu referencji lambda lub metody. Jest to podobne do podejścia refleksyjnego (które przechodzi Class), ale tutaj nie używamy refleksji.

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

Na przykład, jest to używane przez <A> A[] Stream.toArray(IntFunction<A[]>).

To może być również wykonane przed Java 8 przy użyciu anonimowych klas, ale jest to bardziej uciążliwe.

Jest to omówione w rozdziale 5 (Generics) Effective Java, 2nd Edition , poz. 25...preferuj listy od tablic

Twój kod będzie działał, chociaż wygeneruje niezaznaczone Ostrzeżenie (które możesz stłumić za pomocą następującej adnotacji:

@SuppressWarnings({"unchecked"})

Jednak prawdopodobnie lepiej byłoby użyć listy zamiast tablicy.

Na stronie projektu OpenJDK jest ciekawa dyskusja na temat tego błędu/funkcji.

Generyki Javy działają poprzez sprawdzanie typów w czasie kompilacji i wstawianie odpowiednich odlewów, ale wymazywanie typów w skompilowanych plikach. To sprawia, że biblioteki generyczne są użyteczne przez kod, który nie rozumie generycznych (co było celową decyzją projektową), ale co oznacza, że zwykle nie możesz dowiedzieć się, jaki jest typ w czasie uruchamiania.

Publiczny konstruktor Stack(Class<T> clazz,int capacity) wymaga przekazania obiektu klasy w czasie wykonywania, co oznacza, że informacja o klasie jest dostępna w czasie wykonywania do kod, który tego potrzebuje. A forma Class<T> oznacza, że kompilator sprawdzi, czy przekazany obiekt klasy jest dokładnie obiektem klasy dla typu T. nie jest podklasą T, nie superklasą T, ale dokładnie T.

Oznacza to, że można utworzyć obiekt array odpowiedniego typu w konstruktorze, co oznacza, że typ obiektów przechowywanych w kolekcji będzie sprawdzany w momencie ich dodania do kolekcji.

Cześć chociaż wątek jest martwy, chciałbym zwrócić na to uwagę:

Generics jest używany do sprawdzania typu podczas kompilacji:

• dlatego celem jest sprawdzenie, czy to, co przychodzi, jest tym, czego potrzebujesz.
To, co zwracasz, jest tym, czego potrzebuje konsument.
• Sprawdź to:

Nie martw się o Ostrzeżenia typu podczas pisania klasy generycznej. Martw się, gdy go używasz.

Co z tym rozwiązaniem?

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

Zobacz też:

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

Konwertuje listę dowolnego rodzaju obiektów na tablicę tego samego typu.

Znalazłem szybki i łatwy sposób, który działa dla mnie. Zauważ, że używałem tego tylko w Java JDK 8. Nie wiem czy będzie działać z poprzednimi wersjami.

Chociaż nie możemy utworzyć instancji tablicy generycznej określonego parametru typu, możemy przekazać już utworzoną tablicę do konstruktora klasy generycznej.

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

    // ...

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

    // Do whatever with the array...
}

Teraz w main możemy utworzyć tablicę TAK:

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

        // ...

    }
}

Aby uzyskać większą elastyczność z tablicami, możesz użyć listy połączonej np. ArrayList i inne metody znalezione na jawie.util.Klasy ArrayList.

Przykładem jest użycie Java reflection do utworzenia tablicy. Robienie tego na ogół nie jest zalecane, ponieważ nie jest to bezpieczne. Zamiast tego powinieneś użyć wewnętrznej listy i w ogóle unikać tablicy.

Zrobiłem ten fragment kodu, aby odtworzyć instancję klasy, która jest przekazywana do prostego automatycznego narzędzia testowego.

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

Zwróć uwagę na ten segment:

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

Dla tablicy inicjującej gdzie tablica.newInstance (class of array, size of array) . Klasa może być zarówno prymitywna (int.class) i object (Integer.klasy).

Nie musisz przekazywać argumentu klasy konstruktorowi. Spróbuj tego.

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

I

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

Wynik:

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

W rzeczywistości łatwiejszym sposobem na to jest utworzenie tablicy obiektów i oddanie jej do żądanego typu, jak w poniższym przykładzie:

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

Gdzie SIZE jest stałą i {[2] } jest identyfikatorem typu

Przekazywanie listy wartości...

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

Wymuszona Obsada sugerowana przez innych ludzi nie sprawdziła się dla mnie, rzucając wyjątek od nielegalnego castingu.

Jednak ta ukryta Obsada działała dobrze:

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

Gdzie element jest klasą zdefiniowaną i zawierającą element:

private K value;

W ten sposób otrzymasz tablicę typu K (jeżeli element ma tylko wartość) lub dowolnego typu ogólnego, który chcesz zdefiniować w elemencie klasy.

Nikt inny nie odpowiedział na pytanie, co się dzieje w zamieszczonym przez Ciebie przykładzie.

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

Jak mówili inni, generyki są "kasowane" podczas kompilacji. Tak więc w czasie wykonywania instancja generyczna nie wie, jaki jest jej typ komponentu. Powód tego jest historyczny, Sun chciał dodać generyki bez naruszania istniejącego interfejsu (zarówno źródłowego, jak i binarnego).

Tablice natomiast znają swój typ komponentu w czasie wykonywania.

Ten przykład działa wokół problemu poprzez kod, który wywołuje konstruktor (który zna Typ) przekazuje parametr mówiący klasie wymagany typ.

Więc aplikacja skonstruowałaby klasę z czymś w rodzaju

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

I konstruktor wie teraz (w czasie wykonywania), jaki jest typ komponentu i może użyć tych informacji do skonstruowania tablicy poprzez API reflection.

Array.newInstance(clazz, capacity);

Wreszcie mamy Typ cast, ponieważ kompilator nie ma możliwości dowiedzenia się, że tablica zwracany przez Array#newInstance() jest prawidłowym typem (chociaż wiemy).

Ten styl jest trochę brzydki, ale czasami może być najmniej złym rozwiązaniem dla tworzenia typów generycznych, które muszą znać swój typ komponentu w czasie wykonywania z jakiegokolwiek powodu (tworzenie tablic lub tworzenie instancji ich typu komponentu, itp.).

Znalazłem coś w rodzaju pracy wokół tego problemu.

Poniższy wiersz wyświetla błąd tworzenia ogólnej tablicy

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

Jeśli jednak zamknę List<Person> w oddzielnej klasie, to zadziała.

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


public class PersonList {

    List<Person> people;

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

Możesz ujawnić ludzi z listy osób klasowych przez gettera. Poniższy wiersz da ci tablicę, która ma List<Person> w każdym elemencie. Innymi słowy tablica List<Person>.

PersonList[] personLists=new PersonList[10];

Potrzebowałem czegoś takiego w jakimś kodzie, nad którym pracowałem i właśnie to zrobiłem, aby go dostać praca. Jak na razie żadnych problemów.

Można utworzyć tablicę obiektów i wrzucić ją do e wszędzie. Tak, to nie jest zbyt czysty sposób, ale przynajmniej powinien zadziałać.

Spróbuj tego.

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

Łatwe, choć niechlujne obejście tego problemu polegałoby na zagnieżdżeniu drugiej klasy "posiadacza" wewnątrz głównej klasy i użyciu jej do przechowywania danych.

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

Może niezwiązane z tym pytaniem, ale podczas gdy otrzymywałem błąd "generic array creation " za użycie

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

Z@SuppressWarnings({"unchecked"}) poznaję następujące prace (i pracowały dla mnie):

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

Zastanawiam się, czy ten kod stworzy efektywną tablicę generyczną?

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

Edit: być może alternatywnym sposobem utworzenia takiej tablicy, jeśli wymagany rozmiar byłby znany i mały, byłoby po prostu podanie wymaganej liczby "null" do polecenia zeroArray?

Choć oczywiście nie jest to tak wszechstronne jak użycie kodu createArray.

Przydałby się gips:

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

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

Znalazłem dość unikalne rozwiązanie, aby ominąć niemożność zainicjowania tablicy generycznej. Co musisz zrobić, to utworzyć klasę, która przyjmuje zmienną ogólną T w następujący sposób:

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

I wtedy w twojej klasie tablicy po prostu zacznij Tak:

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

Uruchomienie new Generic Invoker[] spowoduje problem z niezaznaczonym, ale w rzeczywistości nie powinno być żadnych problemów.

Aby uzyskać z tablicy należy wywołać tablicę [i].zmienna Tak:

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

Reszta, jak zmiana rozmiaru tablicy może być wykonywana za pomocą tablic.copyOf () like so:

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

I funkcję add można dodać Tak:

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

private E a[];
private int size;

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

Tworzenie generycznych tablic jest niedozwolone w Javie, ale można to zrobić tak:

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