"Class<T> clazz" im Constructor - auch für int möglich?

[marcobolten]

Hi,
ich bin dabei, mir eine generische Arrayklasse zu basteln (nutze ich später für Sortierverfahren). Ich kenne ArrayList, will aber Java lernen (komme von C++) und daher gerade lieber selber was bauen.

Mein Constructor sieht so aus:

public ArrayClass(Class<T> clazz, int capacity)
    {
        m_length = 0;
        m_capacity = capacity;
        m_elements = (T[]) Array.newInstance(clazz, capacity);
    }

Ich habe, diesem Beispiel folgend, die Klasse so instantiiert:

ArrayClass<String> myArray = new ArrayClass(String.class, 5);

Das funktioniert.

ArrayClass<int> myArray2 = new ArrayClass(int.class, 5);

hingegen gibt die Fehlermeldung (beim ersten int): unexpected type / required: reference / type: int

Kann man so etwa auch mit int/boolean/long etc. machen?

 

[httpdigest]

Kann man so etwa auch mit int/boolean/long etc. machen?

Nein. Zumindest nicht direkt bzw. mit den primitiven Typen.

Java (im Gegensatz zu z.B. C++ Templates) verwendet keinen Templating-Ansatz sondern Type Erasure für die Umsetzung von parametrischem Polymorphismus (aka. "Generics" in Java).
Das bedeutet, dass jedes Typargument einer generischen Klasse immer von java.lang.Object ableiten muss. Das tun die primitiven Typen nicht, weil sie keine Referenztypen sind.

Um dem zu begegnen, gibt es die "Wrapperklassen" wie etwa java.lang.Integer, java.lang.Boolean oder java.lang.Long. Diese können als Typargumente verwendet werden.

 

[marcobolten]

Vielen Dank, httpdigest!

Ich werde im Moment nur teilschlau aus Type Erasure, werde das aber in Ruhe nachlesen. Das scheint eine wichtige und grundsätzliche Sache zu sein, die Java- und C++-Denken unterscheidet. Danke für den Input!

Der letzte Satz heißt aber für meine Frage dann eigentlich doch "ja", denn

ArrayClass<java.lang.Integer> myArray2 = new ArrayClass(java.lang.Integer.class, 5);

scheint anstandslos zu funktionieren.
Ein Aufruf mit

int i = 4;
myArray2.append(i);

funktioniert auch - ich freue mich gerade sehr. Oder übersehe ich da größere Nachteile?

 

[KonradN]

Oder übersehe ich da größere Nachteile?

Du solltest Dir bewusst sein, dass int immer einen Wert hat aber ein Integer kann auch null sein. Sprich: ein myArray2.append(null) würde erst einmal auch funktionieren. Wenn Du dann aber hier den Wert in einen int ausliest, dann bekommst Du eine NPE.

Das ist ein Punkt, auf den man ggf. achten sollte.

 

[temi]

Was man aus dem Beitrag von @KonradN herauslesen kann, noch einmal explizit erwähnt: Bei Integer handelt es sich, im Gegensatz zu int, um eine Klasse (die einen int-Wert kapselt) und um sie verwenden zu können werden Instanzen davon benötigt.

Der Compiler erzeugt diese Instanzen automatisch, anstatt von Integer i = new Integer(42); funktioniert dadurch auch Integer i = 42; anstandslos.

Du kommst ja aus einer Sprache, wo gerne auf Geschwindigkeit geachtet wird. Obwohl die Regel lautet, dass man nicht optimieren soll (die Regel ist länger, ich bin zu faul), sollte man hier etwas aufpassen:

Long sum = 0L;
for (long i = 0; i > Integer.MAX_VALUE; i++) {
    sum += i; // Achtung!
}

Da die Variable sum ein Long (mit groß geschriebenem L) ist, werden hier implizit sehr viele Instanzen innerhalb der Schleife erzeugt! Das wird sich in der Laufzeit deutlich bemerkbar machen.

 

[temi]

Mein Constructor sieht so aus:

public ArrayClass(Class<T> clazz, int capacity)
{
m_length = 0;
m_capacity = capacity;
m_elements = (T[]) Array.newInstance(clazz, capacity);
}

Was übrigens auch funktioniert:

public ArrayClass(int capacity)
    {
        m_length = 0;
        m_capacity = capacity;
        m_elements = (T[]) new Object[capacity];
    }

Und die Erzeugung einer Instanz davon:

ArrayClass<String> myArray = new ArrayClass<>(5);

 

[temi]

Hier solltest du aufpassen, bzw. sollte eine gute IDE eine Warnung spendieren ("RAW use of parameterized class"):

ArrayClass<String> myArray = new ArrayClass(String.class, 5);

Du hast bei der Erzeugung deiner ArrayClass die "<>" weg gelassen.

Eine Instanz einer generischen Klasse wird normalerweise so erzeugt:

ArrayList<String> list = new ArrayList<String>();

// bzw. unter Verwendung eines Interfaces

List<String> list = new ArrayList<String>();

Seit Java 1.7 gibt es den Diamond-Operator, so das dieses die einfachere Form davon ist:

List<String> list = new ArrayList<>();

Vor allem, wenn du bei der Deklaration der Variablen, den Rohtypen verwendest, hat das erhebliche Folgen. Da der Rohtyp "Object" entspricht, erhältst du eine ArrayList<Object> und kannst jeden beliebigen Typen übergeben:

ArrayList list = new ArrayList<String>(); // Typangabe bei der Deklaration von 'list' vergessen
 
list.add("Hallo Welt"); // funktioniert erst mal
list.add(42); // das auch

 

[Neumi5694]

Seit Java 1.7 gibt es den Diamond-Operator, so das dieses die einfachere Form davon ist:

List<String> list = new ArrayList<>();

Nur der Vollständigkeit halber: Mittlerweile kann man auch den umgekehrten Weg gehen.

var list = new ArrayList<String>();

Damit behandelt der Compiler "list" als "ArrayList<String>". Merke: Es ist dann die 'echte' Klasse (mit allen zusätzlichen Eigenschaften), nicht das Interface. Links wird verwendet, was rechts steht.

Noch ein kleiner Punkt zur Geschwindigkeit. Davon abgesehen, dass der Compiler eh gewisse Optimierungen vornimmt, ist der Geschwindkeitsverlust einer "Long" Schleife irrelevant. Dies wäre bei Prozessoren ein Problem, die keine Pipeline haben, also sehr, sehr ,sehr, sehr alten Prozessoren. Mittlerweile sind aber mehrere Befehle in einer Pipeline genauso schnell bearbeitet wie ein einzelner. Die richtige Länge einer Pipeline ist immer ein Balanceakt beim Design.Viele Schleifen mit je einem Befehl sind allerdings langsamer als eine Schleife mit mehreren Befehlen.