ArrayLists initialisieren

[JavAlex]

Hey,

ich muss bis nächste Woche ein kleines Java-Programm schreiben, hab es auch fast fertig, nur es tauchen noch folgende beiden Fehlermeldungen auf:

Buckets.java:13:  expected
    ArrayList > B = new ArrayList();
              ^

Liste.java:11:  expected
    ArrayList  L = new ArrayList();
              ^
2 errors

Die entsprechenden beiden Zeilen im Quelltext lauten:

Buckets:13:   ArrayList <ArrayList <Knoten>> B = new ArrayList();
Liste:11:        ArrayList <Knoten> L = new ArrayList();

Ich kann absolut nicht verstehen, was an diesen beiden Zeilen falsch sein soll
Es werden ja ganz normal zwei ArrayLists initialisiert. Und Elemente vom Typ Knoten sind durch die Klasse "Knoten.java" mit einen ganz normalen Konstruktor definiert.

Wäre super, wenn mir jemand von euch helfen könnte.

Vielen Dank schon mal!

 

[Schandro]

villeicht benutzt du einen Compiler unter Version 5, damals gab es Generics noch nicht.

Und Elemente vom Typ Knoten sind durch die Klasse "Knoten.java" mit einen ganz normalen Konstruktor definiert.

Nur so zum Verständniss:
Es ist an dieser Stelle des Codes völlig egal welche Konstruktoren der Typ hat, ob er welche hat, oder ob es ein Interface ist welches naturgemäß keine Konstruktoren haben kann oder sonstwas. Es kommt nur drauf an das es irgendein existierender "Typ" ist.

 

[Schandro]

-.- doppelpost

 

[JavAlex]

Sorry, aber bin da echt gerade dran am Verzweifeln, deshalb hab ichs in mehrere Foren gepostet.

 

[Schandro]

ne, ich hab damit meinen doppelpost innerhalb dieses Threads gemeint, ich hab den 2. editiert damit nicht zweimal dasselbe hier steht.

Lags jetzt an der Compiler Version?

 

[JavAlex]

Achso... oops..

Danke für deine schnelle Antwort.

An der Compiler-Version dürfte es eigentlich nicht liegen. Ich hab Java 5 auf meinem PC, da kann ich es auch einwandfrei kompilieren. Ich muss es aber bei der Abgabe dann auf einen Server hochladen. Und da meckert der Compiler.

Uns wurde allerdings gesagt, dass wir Java 5 benutzen dürfen, also müsste auf dem Server eigentlich auch Java 5 installiert sein.

 

[Marco13]

Ganz pragmatisch: Schreib' das Programm den Vorgaben entsprechend, mit Java 5, und compiliere es lokal bei dir auf dem PC. Wenn es fehlerfrei compiliert, schick' es zum Server. Wenn der Server dann meckert, hat der Server einen Hau - dann schick' dem Verantwortlichen eine Mail, mit deinem Programm als Anhang, und schreib: "Geht lokal, Server meckert -> Server blöd"

 

[JavAlex]

Danke schon mal für eure Hilfe!

Hmm... ich muss auf jeden Fall festlegen, dass die ArrayList nur Knoten enthält, sonst klappt der Rest des Programms nicht. Gibts denn noch eine andere Möglichkeit außer Generics, um das festzulegen? Irgendwie muss es ja auch vor Java 5 schon möglich gewesen sein, solche Probleme zu lösen. Vielleicht irgendwie über einen Punktoperator? Sowas wie

Liste.type()=Knoten;

oder so?

 

[Marco13]

Ne, casten:

ArrayList list = new ArrayList();
list.add(new Knoten());
...
Knoten knoten = (Knoten)list.get(0);


Das unpraktische dabei ist, dass das leichter zu Fehlern führt, wenn man sich in bezug auf den Inhelt der Liste mal irrt:

list.add("Hallo");
Knoten knoten = (Knoten)list.get(1); // Erwartet Knoten, findet String: -> ClassCastException!

 

[Schandro]

Nö, kannst du nicht (außer du machst ne eigene Klasse "ArrayListOnlyWithKnotenElements" in der "Knoten " als Typ aller Elemente hard reincodiert ist, das wäre aber ziemlich umständlich und unnötig)

Ansonsten musst du halt bei jeden auslesen der List kontrollieren ob das Object was du bekommen hast wirklich ein Knoten ist und dementsprechend casten.... (siehe Marco13 's Post)

 

[JavAlex]

@Marco13: Du hast ja eigentlich vollkommen recht. Nur dann heißt es von den Verantwortlichen "Server nicht blöd, Programm blöd, hätte ich anders schreiben müssen
-> Note schlecht"

 

[Marco13]

Das schöne ist, dass es (bei Mathematik und Informatik und speziell) beim Programmieren da nicht so viel Interpretationsspielraum gibt.

ArrayList<ArrayList<Knoten>> K = new ArrayList<ArrayList<Knoten>>();

ist gültiger Java-Code. Da gibt's kein gut, mittel, besser, schöner, schlechter - nur RICHTIG oder FALSCH. (Und wenn es falsch sein sollte, hättest du hier irgendwelche Einschränkungen oder Anforderungen noch nicht genannt - vielleicht verbieten sie ja Variablennamen, die nur aus einen Buchstaben bestehen - das muss dann aber irgendwo definiert sein!). Und ... wenn du glaubst, dass die Leute, die diesen Server geschrieben haben, keine Fehler machen ... huiui...


EDIT: Naja...
List<List<Knoten>> K = new ArrayList<ArrayList<Knoten>>();
wäre natürlich DOCH "schöner", aber darum geht's ja erstmal nicht

 

[JavAlex]

Casten hatte ich vor den Generics mal versucht. Hab dunkel in Erinnerung, dass das auch zu irgendeinem Problem geführt hat, weshalb ich dann zu den Generics gewechselt bin. Ich war mir damals auch nicht sicher, ob man etwas zu einem selbstdefinierten Datentyp "Knoten" casten kann, oder ob man nur etwas zu fest vorgegebenen Datentypen, wie int, String, usw., casten kann. Aber ich glaub, ich werd das morgen in aller Ruhe nochmal mit casten versuchen! Danke!

 

[Marco13]

Ich würde dir aber empfehlen (bevor du da jetzt unnötig Zeit reinsteckst, und irgendwas durch casts "häßlicher" machst, als es mit Generics sein könnte) mal mit einer Mail anzufragen.

 

[Schandro]

Du kannst zu jeden existierenden Typen casten, also auch zu deinen selbst definierten.

 

[JavAlex]

Stimmt, einerseits ist es schön, dass man in der Mathematik und Informatik genau sagen kann, ob etwas richtig oder falsch ist.

Andererseits ist man deshalb auch gezwungen, manchmal stundenlang seine Fehler zu suchen und sich zu fragen, warum das Programm nicht läuft. Germanisten z.B. haben es da viel einfacher, wenn sie einen Aufsatz schreiben oder irgendein Buch interpretieren... so ein Aufsatz ist dann zumindest "ein bisschen richtig" und sie müssen nicht stundenlang Fehler suchen... oder Interpretationen sind weder richtig noch falsch... tja....
Aber nichts gegen Germanisten

 

[JavAlex]

Ja.. hab jetzt nochmal eine Mail geschrieben.

Mit Casts wird das ganze ziemlich wirklich unübersichtlich. In der Klasse Knoten gibt es z.B. eine int-Variable knotennummer.
Und in ArrayLists kann ich dann einfach auf

int n = List.get(i).knotennummer;

zugreifen.
Wenn ich das ganze caste, müsste ich jeden Knoten, auf dessen Knotennummer ich zugreifen möchte, wahrscheinlich erst zwischenspeichern, oder?

Knoten K = (Knoten)List.get(i);
n = K.knotennummer;

 

[Schandro]

n = ((Knoten)List.get(i)).knotennummer;

geht auch.

Warum benutzt du bei der Klasse Knoten den keine getter/setter?

 

[JavAlex]

EDIT: Naja...
List<List<Knoten>> K = new ArrayList<ArrayList<Knoten>>();
wäre natürlich DOCH "schöner", aber darum geht's ja erstmal nicht

Hatte ich auch zuerst, aber das hätte dann bedeutet: noch mehr spitze Klammern und damit noch mehr Fehlermeldungen
So konnte ich mich zumindest schon mal von 7 Fehlermeldungen auf 2 reduzieren.

Hatte am Anfang auch sowas wie

@SuppressWarning("unchecked")

aber leider war das @-Zeichen für den Server auch ein unbekanntes ASCII-Zeichen, deshalb musste ich das auch rausnehmen.

 

[JavAlex]

Hmm... joah... getter und setter wären auch eine Überlegung wert. Hatte ich bisher noch gar nicht drüber nachgedacht, weil die Knotennummer nur einmal gesetzt werden muss. Und das mach ich halt direkt beim Initialisieren. Und später möchte ich die im Grunde nur noch abfragen.

Aber getter/setter ist eigentlich eine gute Idee.

 

[Schandro]

Hatte ich auch zuerst, aber das hätte dann bedeutet: noch mehr spitze Klammern und damit noch mehr Fehlermeldungen
So konnte ich mich zumindest schon mal von 7 Fehlermeldungen auf 2 reduzieren.

Ist doch völlig egal ob du 7 oder 2 Fehlermeldungen des selben Typs hast, wenn du sie trotzdem nicht komplett abstellen kannst.

 

[JavAlex]

Huuuii.. eben war ich noch Bit, jetzt bin ich schon Byte