Jak utworzyć ogólną tablicę w Javie?

Ze względu na implementację generycznych Java, nie możesz mieć takiego kodu:

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

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

Jak mogę to zaimplementować, zachowując bezpieczeństwo typu?

Na forach Java zobaczyłem takie rozwiązanie:

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

Ale tak naprawdę nie rozumiem, co się dzieje.

W zamian muszę zadać pytanie: czy Twoje GenSet„zaznaczone” czy „niezaznaczone”? Co to znaczy?

• Sprawdzone : mocne pisanie . GenSetwie wyraźnie, jaki typ obiektów zawiera (tzn. jego konstruktor został jawnie wywołany z Class<E>argumentem, a metody zgłoszą wyjątek, gdy zostaną przekazane argumenty, które nie są typu E. Zobacz Collections.checkedCollection.

  -> w takim przypadku powinieneś napisać:

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

• Niezaznaczone : słabe pisanie . W rzeczywistości żaden sprawdzanie typu nie jest wykonywane na żadnym obiekcie przekazywanym jako argument.

  -> w takim przypadku powinieneś napisać

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

  Zauważ, że typem komponentu tablicy powinno być usunięcie parametru 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];
      }
  
      ...
  }

Wszystko to wynika ze znanej i celowej słabości generyków w Javie: zostało zaimplementowane przy użyciu skasowania, więc klasy „ogólne” nie wiedzą, z jakim argumentem typu zostały utworzone w czasie wykonywania, a zatem nie mogą dostarczyć typu bezpieczeństwo, chyba że wdrożony zostanie jakiś jawny mechanizm (kontrola typu).

Możesz to zrobić:

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

Jest to jeden z sugerowanych sposobów implementacji ogólnej kolekcji w Effective Java; Pozycja 26 . Bez błędów typu, nie trzeba wielokrotnie rzutować tablicy. Jednak to wyzwala ostrzeżenie, ponieważ jest potencjalnie niebezpieczny i powinien być stosowany z ostrożnością. Jak wyszczególniono w komentarzach, Object[]teraz jest to maskarada naszego E[]typu i może powodować nieoczekiwane błędy, ClassCastExceptionjeśli zostanie użyta niezgodnie z przeznaczeniem.

Zasadniczo takie zachowanie jest bezpieczne, o ile tablica rzutowania jest używana wewnętrznie (np. Do tworzenia kopii zapasowej struktury danych) i nie jest zwracana ani narażana na kod klienta. Jeśli musisz zwrócić tablicę typu ogólnego do innego kodu, wspomniana Arrayklasa odbicia jest właściwą drogą.

Warto wspomnieć, że tam, gdzie to możliwe, będziesz mieć dużo więcej czasu na pracę z Lists niż z tablicami, jeśli używasz ogólnych. Z pewnością czasami nie masz wyboru, ale korzystanie ze struktury kolekcji jest znacznie bardziej niezawodne.

Oto jak używać ogólnych, aby uzyskać tablicę dokładnie tego, czego szukasz, przy jednoczesnym zachowaniu bezpieczeństwa typu (w przeciwieństwie do innych odpowiedzi, które albo zwrócą Objecttablicę, albo spowodują pojawienie się ostrzeżeń w czasie 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];  
    }  
}

To się kompiluje bez ostrzeżeń i jak widać w main, dla dowolnego typu deklarowanego jako instancję GenSet, można przypisać ado tablicy tego typu i można przypisać element ado zmiennej tego typu, co oznacza, że ​​tablica a wartości w tablicy są poprawnego typu.

Działa przy użyciu literałów klasowych jako tokenów typu wykonawczego, jak omówiono w samouczkach Java . Literały klas są traktowane przez kompilator jako instancje java.lang.Class. Aby użyć jednego, po prostu podążaj za nazwą klasy za pomocą .class. String.classDziała więc jako Classobiekt reprezentujący klasę String. Działa to również w przypadku interfejsów, wyliczeń, tablic dowolnego wymiaru (np. String[].class), Prymitywów (np. int.class) I słowa kluczowego void(tj void.class.).

Classsam jest ogólny (zadeklarowany jako Class<T>, gdzie Toznacza typ reprezentowany przez Classobiekt), co oznacza, że ​​typem String.classjest Class<String>.

Tak więc, za każdym razem, gdy wywołujesz konstruktor GenSet, przekazujesz literał klasy dla pierwszego argumentu reprezentującego tablicę GenSetzadeklarowanego typu instancji (np. String[].classDla GenSet<String>). Zauważ, że nie będziesz w stanie uzyskać tablicy prymitywów, ponieważ prymitywów nie można używać do zmiennych typu.

Wywołanie metody wewnątrz konstruktora castzwraca przekazany Objectargument rzutowany do klasy reprezentowanej przez Classobiekt, na którym wywołano metodę. Wywołanie metody statycznej newInstancew java.lang.reflect.Arrayzwraca jako Objecttablicę typu reprezentowanego przez Classobiekt przekazany jako pierwszy argument i o długości określonej przez intprzekazany jako drugi argument. Wywołanie metody getComponentTypezwracającej ClassPrzedmiotem reprezentującym typ komponentu tablicy reprezentowane przez Classobiekt na którym sposób został nazwany (na przykład String.classprzez String[].class, nulljeśli Classobiekt nie stanowią macierz).

To ostatnie zdanie nie jest do końca dokładne. Wywołanie String[].class.getComponentType()zwraca Classobiekt reprezentujący klasę String, ale jego typ Class<?>nie Class<String>jest, dlatego nie można zrobić czegoś takiego jak poniżej.

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

To samo dotyczy każdej metody, Classktóra zwraca Classobiekt.

W odniesieniu do komentarza Joachima Sauera do tej odpowiedzi (nie mam wystarczającej reputacji, aby skomentować ją osobiście), przykład użycia cast do T[]spowoduje ostrzeżenie, ponieważ kompilator nie może zagwarantować bezpieczeństwa typu w tym przypadku.

Edytuj w odniesieniu do komentarzy Ingo:

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

To jedyna odpowiedź bezpieczna dla typu

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, po prostu dodaj []parametry i parametry wymiaru do newInstance()( Tjest parametrem typu, clsa Class<T>, d1przez, d5są 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()szczegóły.

W Javie 8 możemy wykonać rodzaj ogólnego tworzenia tablic za pomocą lambda lub odwołania do metody. Jest to podobne do podejścia refleksyjnego (które przechodzi a 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[]>).

Można to również zrobić przed wersją Java 8 przy użyciu anonimowych klas, ale jest to bardziej kłopotliwe.

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

Twój kod będzie działał, chociaż będzie generował niesprawdzone ostrzeżenie (które możesz pominąć za pomocą następującej adnotacji:

@SuppressWarnings({"unchecked"})

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

Ciekawa dyskusja na temat tego błędu / funkcji na stronie projektu OpenJDK .

Nie trzeba przekazywać argumentu Konstruktor do klasy. Spróbuj tego.

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

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]

Generyczne programy Java działają poprzez sprawdzanie typów w czasie kompilacji i wstawianie odpowiednich rzutowań, ale kasowanie typów w skompilowanych plikach. Dzięki temu biblioteki ogólne mogą być używane przez kod, który nie rozumie generycznych (co było świadomą decyzją projektową), ale co oznacza, że ​​normalnie nie można dowiedzieć się, jaki typ jest w czasie wykonywania.

Konstruktor publiczny Stack(Class<T> clazz,int capacity)wymaga przekazania obiektu klasy w czasie wykonywania, co oznacza, że ​​informacje o klasie są dostępne w czasie wykonywania do potrzebującego kodu. IClass<T> środki tworzą, że kompilator będzie sprawdzić, czy obiekt klasy przechodzą właśnie obiekt Class dla typu T. nie podklasą T, nie nadklasą T, ale właśnie T.

Oznacza to, że możesz utworzyć w swoim konstruktorze obiekt tablicowy odpowiedniego typu, co oznacza, że ​​typ obiektów przechowywanych w Twojej kolekcji będzie sprawdzany pod kątem typów w momencie dodawania do kolekcji.

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

Generics służy do sprawdzania typu w czasie kompilacji:

• Dlatego celem jest sprawdzenie, czy to, czego potrzebujesz, jest tym, czego potrzebujesz.
• Zwrócisz to, czego potrzebuje konsument.
• Sprawdź to:

Nie martw się ostrzeżeniami rzutowania podczas pisania klasy ogólnej. Martw się, gdy go używasz.

Co z tym rozwiązaniem?

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

Działa i wygląda na zbyt prosty, aby był prawdziwy. Czy jest jakaś wada?

Zobacz także ten kod:

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 obiektu na tablicę tego samego typu.

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

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

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

    // ...

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

    // Do whatever with the array...
}

Teraz w zasadzie możemy utworzyć tablicę w następujący sposób:

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

        // ...

    }
}

Dla większej elastyczności macierzy możesz użyć połączonej listy, np. ArrayList i inne metody znalezione w klasie Java.util.ArrayList.

W przykładzie wykorzystano odbicie Java do utworzenia tablicy. Nie jest to zalecane, ponieważ nie jest to bezpieczne. Zamiast tego powinieneś po prostu użyć wewnętrznej listy i całkowicie unikać tablicy.

Przekazywanie listy wartości ...

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

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

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

Uwaga na ten segment:

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

do inicjowania tablicy gdzie Array.newInstance (klasa tablicy, rozmiar tablicy) . Klasa może być zarówno pierwotna (int. Klasa), jak i obiektowa (Integer.class).

BeanUtils jest częścią wiosny.

W rzeczywistości łatwiejszym sposobem jest utworzenie tablicy obiektów i rzutowanie jej na pożądany typ, jak w poniższym przykładzie:

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

gdzie SIZEjest stałą i Tjest identyfikatorem typu

Przymusowa obsada sugerowana przez innych ludzi nie działała dla mnie, rzucając wyjątek nielegalnego castingu.

Jednak ta domyślna obsada działała dobrze:

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

gdzie pozycja jest zdefiniowaną przeze mnie klasą zawierającą element członkowski:

private K value;

W ten sposób otrzymujesz tablicę typu K (jeśli element ma tylko wartość) lub dowolny typ ogólny, który chcesz zdefiniować w klasie Element.

Nikt inny nie odpowiedział na pytanie, co się dzieje w opublikowanym 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 powiedzieli inni, generycy są „wymazywani” podczas kompilacji. Tak więc w czasie wykonywania instancja rodzaju ogólnego nie wie, jaki jest jego typ komponentu. Przyczyna tego jest historyczna, Sun chciał dodać ogólne, nie psując istniejącego interfejsu (zarówno źródłowego, jak i binarnego).

Tablice z drugiej strony zrób poznać ich typ komponentu przy starcie.

Ten przykład rozwiązuje ten problem, ponieważ kod wywołujący konstruktor (który zna typ) przekazuje parametr informujący klasę o wymaganym typie.

Więc aplikacja zbuduje klasę z czymś podobnym

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

a konstruktor wie teraz (w czasie wykonywania), jaki jest typ komponentu i może wykorzystać te informacje do skonstruowania tablicy za pomocą interfejsu API odbicia.

Array.newInstance(clazz, capacity);

Wreszcie mamy rzutowany typ, ponieważ kompilator nie ma możliwości dowiedzenia się, że zwrócona tablica Array#newInstance()jest poprawnym typem (chociaż wiemy).

Ten styl jest nieco brzydki, ale czasem może być najgorszym rozwiązaniem do tworzenia typów ogólnych, które z jakiegokolwiek powodu muszą znać swój typ komponentu w czasie wykonywania (tworzenie tablic lub tworzenie instancji typu komponentu itp.).

Znalazłem sposób obejścia tego problemu.

Wiersz poniżej generuje ogólny błąd tworzenia tablicy

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

Jeśli jednak opakowuję List<Person>w osobną klasę, to działa.

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


public class PersonList {

    List<Person> people;

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

Możesz wystawiać ludzi z klasy PersonList przez getter. W poniższej linii otrzymasz 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 to zadziałało. Jak dotąd żadnych problemów.

Możesz stworzyć tablicę Object i rzucić ją na E wszędzie. Tak, nie jest to bardzo czysty sposób, ale powinien przynajmniej dział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>();
        }
    }
}

Łatwym, aczkolwiek niechlujnym obejściem tego problemu byłoby zagnieżdżenie drugiej klasy „holder” wewnątrz głównej klasy i użycie jej do przechowywania danych.

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

Może nie ma to związku z tym pytaniem, ale podczas otrzymywania generic array creationbłędu „ ” występowałem

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

Odnajduję następujące prace (i pracowałem dla mnie) z @SuppressWarnings({"unchecked"}):

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

Zastanawiam się, czy ten kod stworzyłby skuteczną ogólną tablicę?

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

Edycja: Być może alternatywnym sposobem utworzenia takiej tablicy, jeśli wymagany rozmiar byłby znany i mały, byłoby po prostu wprowadzenie wymaganej liczby „zerowych” do polecenia zeroArray?

Chociaż oczywiście nie jest to tak wszechstronne, jak użycie kodu createArray.

Możesz użyć obsady:

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

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

Znalazłem dość unikalne rozwiązanie, które pomija niemożność zainicjowania ogólnej tablicy. Musisz stworzyć klasę, która przyjmuje zmienną ogólną T w taki sposób:

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

a następnie w klasie macierzy po prostu zacznij tak:

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

uruchomienie a new Generic Invoker[]spowoduje problem z niezaznaczonym, ale tak naprawdę nie powinno być żadnych problemów.

Aby uzyskać z tablicy, należy wywołać tablicę [i] .variable w następujący sposób:

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

Resztę, na przykład zmianę rozmiaru tablicy, można wykonać za pomocą Arrays.copyOf () w następujący sposób:

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

A funkcję dodawania można dodać w następujący sposób:

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

Według vnportnoy składnia

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

tworzy tablicę pustych referencji, które należy wypełnić jako

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

który jest bezpieczny dla typu.

private E a[];
private int size;

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

Ogólne tworzenie tablic jest niedozwolone w Javie, ale można to zrobić w podobny sposób

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