Werte einer Generic LinkedList zusammenrechenen

[o1o1oo111o]

Hallo. Ich habe eine Aufgabe bekommen eine Methode zu implementieren die LinkedList von beliebigen typen entgegennimmt. Falls der Typ der Liste int ist, dann sollen die Werte summiert werden, ansonsten soll -1 ausgegeben werden. Meine frage ist wie ich die werte von einem Generic Type zusammenrechnen kann?
Soweit bin ich gekommen. Könnte mir jemand weiterhelfen? Wäre sehr nett

    public static void main(String[] args) {
        List <Integer> intListe = new LinkedList<>();
        intListe.add(2);
        intListe.add(2);
        intListe.add(4);
        intListe.add(5);
        

        List <String> strListe = new LinkedList<>();
        strListe.add("Hallo");


        System.out.println(listensumme(intListe));
        System.out.println(listensumme(strListe));


    }

    public static <T> int listensumme(List<T> liste){
        if(liste.get(0) instanceof Integer) {
            
            for (Iterator it = liste.iterator(); it.hasNext();) //Hier ist mein Problem
                T i += ((T)it.next());
                return i;
            }

        }
        return -1;
    }

 

[Flown]

Wie würdest du ohne Generics (ergo der Typ T ist immer Integer) eine Summe bilden mit einer Schleife?

 

[o1o1oo111o]

Ich hätte es so gemacht:

List <Integer> intListe = new LinkedList<>();
        intListe.add(2);
        intListe.add(2);
        intListe.add(4);
        intListe.add(5);


        Integer i = 0;
        for (Iterator<Integer> it = intListe.iterator(); it.hasNext();) {
             i += it.next();
        }
        System.out.println(i);

 

[httpdigest]

Da Java/JVM für Generics Type Erasure verwendet, gibt es kein statisches oder dynamisches Dispatch basierend auf dem Typargument eines generischen Typs. Du kannst also z.B. keine zwei Methoden haben:

public static void doSomethingWith(List<Integer> intList) {...}
public static void doSomethingWith(List<String> stringList) {...}

Du kannst hier nur Reflection (oder instanceof) verwenden, um den aktuellen Typ eines Objektes in der Liste auf Integer zu prüfen.

 

[Flown]

Der Ansatz war ja gar nicht mal schlecht. Bring jetzt deinen ersten Versuch und die Summierung zusammen (Tipp: der Cast auf (T) ist falsch du weißt ja schon, dass es ein Integer ist - ergo kannst du darauf casten)

 

[o1o1oo111o]

Der Ansatz war ja gar nicht mal schlecht. Bring jetzt deinen ersten Versuch und die Summierung zusammen (Tipp: der Cast auf (T) ist falsch du weißt ja schon, dass es ein Integer ist - ergo kannst du darauf casten)

Ich habe es mit Type <Integer> versucht jedoch kommt da ein fehler, dass Iterator vom Type <T> sein muss:

    public static <T> int listensumme(List<T> liste){

        if(liste.get(0) instanceof Integer) {
            Integer i = 0;
            for (Iterator<Integer> it = liste.iterator(); it.hasNext();) {  //Hier Fehler
                i += it.next();
                return i;
            }

        }
        return -1;
    }

Ich habe versucht Type von Iterator auf <T> zu wechseln, da kommt jedoch auch eine Fehler, dass man Integer und <T> nicht zusammenrechenn kann:

    public static <T> int listensumme(List<T> liste){

        if(liste.get(0) instanceof Integer) {
            Integer i = 0;
            for (Iterator<T> it = liste.iterator(); it.hasNext();) {
                i += it.next();  //Hier Fehler
                return i;
            }

        }
        return -1;
    }

Und Zuletzt habe ich versuch die Variable zum summieren auf Type <T> zu setzen aber ich kann der kein int wert zuweisen:

    public static <T> int listensumme(List<T> liste){

        if(liste.get(0) instanceof Integer) {
            <T> i = 0; //Hier Fehler
            for (Iterator<T> it = liste.iterator(); it.hasNext();) {
                i += it.next();
                return i;
            }

        }
        return -1;
    }
}

Komme nicht drauf obwohl ich wahrscheinlich nah an der Lösung bin. Hättest du noch Tipps für mich?

 

[temi]

Noch ein Hinweis (nicht relevant für das Problem):

Integer i = 0; // Integer ist ein Referenztyp
for (...) {  
    i += it.next(); // deshalb wird hier bei jeder Addition ein neues Objekt erzeugt

}

Das kann bei großen Listen Laufzeitrelevanz haben. Verwende für "i" lieber den Wertetyp "int".

 

[temi]

Du könntest auch die "enhanced for-loop" verwenden:

int i = 0;
for (int value : intListe) {
    i += value;
}

Und du könntest dafür die ganze Liste casten (Typ) list, was natürlich schief geht, wenn die Liste keine Elemente "Typ" enthält.

 

[o1o1oo111o]

Du könntest auch die "enhanced for-loop" verwenden:

int i = 0;
for (int value : intListe) {
    i += value;
}

Und du könntest dafür die ganze Liste casten (Typ) list, was natürlich schief geht, wenn die Liste keine Elemente "Typ" enthält.

Wie sollte ich das in einer Generic methode machen?

    public static <T> int listensumme(List<T> liste){

        if(liste.get(0) instanceof Integer) {
            int i = 0;
            for (int v : liste) {
                i += v;

            }
        return i;
        }
        return -1;
    }

Das funktioniert nicht

 

[temi]

Ich habe versucht Type von Iterator auf <T> zu wechseln, da kommt jedoch auch eine Fehler, dass man Integer und <T> nicht zusammenrechenn kann

Um noch darauf zu antworten. Du musst halt das Ergebnis von it.next() noch auf int casten mit (int) it.next()

 

[temi]

Wie sollte ich das in einer Generic methode machen?

Siehe diesen Hinweis:

Und du könntest dafür die ganze Liste casten (Typ) list, was natürlich schief geht, wenn die Liste keine Elemente "Typ" enthält.

Und zwar direkt hier:

for (int v : liste) {

for (int value : (List<Integer>)list) {

oder du verwendest T als Typ und castest später:

for (T value : list) {
    i += (int)value;
}

 

[o1o1oo111o]

Siehe diesen Hinweis:

Und zwar direkt hier:

for (int v : liste) {

for (int value : (List<Integer>)list) {

oder du verwendest T als Typ und castest später:

for (T value : list) {
    i += (int)value;
}

Danke sehr! Ich wusste nicht dass man eine Liste mit (List<Integer>) Catens muss.

 

[temi]

Ich wusste nicht dass man eine Liste mit (List<Integer>) Catens muss

Du möchtest ja in deiner Methode behaupten, dass der Typ T einem bestimmten Typen entspricht, nämlich Integer und diese "Behauptung" ist der Cast. Den generischen Typen T kannst du ja nicht einfach addieren, es könnte sich um alles mögliche handeln. Und du musst auch nicht die ganze Liste casten, sondern kannst auch das einzelne T casten, wie oben geschrieben.

 

[MarvinsDepression]

Zur Typbestimmung habe ich mal eine Frage: Gibt es da einen universellen Weg, festzustellen, ob T gerade für Integer steht.
Ich meine, nur weil ein Cast zu int/Integer geglückt ist, heißet es ja nicht, dass der ursprüngliche Typ nicht irgend ein anderer konvertierbarer Zahlentyp war.
Mit instanceof käme ich auch nicht weiter, wenn die Liste leer ist und somit keine vergleichbare Instanz zur Verfügung steht.
Da stehe ich gerade auf dem Schlauch.

 

[httpdigest]

Reification von Typargumenten ist nur möglich, wenn das Typargument in einer Typdeklarationen vorkommt.
Da dein <T> aber lediglich ein Typparameter an einer Methode ist, gibt es zur Laufzeit keinerlei Möglichkeit mehr (wegen der erwähnten "Type Erasure").

Anders sähe es aus bei etwa:

import java.lang.reflect.ParameterizedType;
import java.util.List;
public class MeineKlasse<T> {
  public void test(List<T> liste) {
    ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
    System.out.println(pt.getActualTypeArguments()[0]); // <- gibt "class java.lang.Integer" aus
  }
  public static void main(String[] args) {
    new MeineKlasse<Integer>() {}.test(null); // <- man achte auf die geschweiften Klammern!!!
  }
}

Hier ist es möglich, auf das konkrete Typargument des Typparameters zuzugreifen, weil aus der generischen Klasse eine Unterklasse mit Typargument erzeugt wird.

Übrigens ist genau das auch ein Trick, der von vielen Serialisierungs/Deserialisierungs-Libraries via GSON oder Jackson angewendet wird: Es wird eine Subklasse von einer generischen Klasse mit konkretem Typargument erzeugt. Das macht daraus dann einen "reifizierbaren" Typ und man bekommt die Typargument zur Laufzeit per Reflection heraus.