Java ForEach - wird geklont?

[Krik]

Moin

Angenommen man hat zB so einen Code:

ArrayList<Object> elemente;

// elemente.add(...);
// ...

For (Object element : elemente) {
  // ...
}

Ist element ein geklontes Element aus der ArrayList, oder ist das eine Referenz auf ein Element in der ArrayList?

Manchmal sind einem auch die grundlegendsten Dinge nicht klar. *seufz*

Gruß
Laurin

 

[Shagg]

Das sollte eine Referenz auf das Objekt im Array sein. Solltest du also ein Element innerhalb der Schleife verändern, so wird diese Veränderung auch im Array stehen.

 

[deveth0]

Natürlich ist es eine Referenz. Diese for-each Schleife macht nix anderes, als eine Schleife, in der du manuell auf jedes Element zugreifst:

for(int i = 0; i < array.size(); i++){
     Element e = array.get(i);
     tralala....
}

In Java bekommst du zu 99,9 % immer Referenzen zu Gesicht. Für Kopien muss man eigentlich immer explizit einen Klon erzeugen.

 

[Krik]

Ok, stimmt. Daran habe ich gar nicht gedacht.

Danke für die schnelle Erklärung.

 

[Banthor]

Ja, du bekommst eine eigene Referenz auf das Originalobjekt der Collection.

Falls du Dir bei solchen Dingen nicht sicher bist kannst du das übrigens sehr leicht prüfen, indem du einfach die Referenzen mit == vergleichst. Kommt true raus, so sind es dieselben Objekte (== prüft auf Objektidentität).

Noch schnell geht es, wenn du im Debugger einfach einen Haltepunkt setzt und dann die ObjektIds der Referenzen vergleichst.

 

[AlbertLast]

unser java prof meinte mal man sollte keine foreach schleifen benutzen
weil mehre sachen verlangt werden,
wie das sich das obejtk nicht verändert in der laufzeit
oder auch das in ihnen keine weiteren schleifen möglich sind.

 

[Krik]

Da hat dein Prof aber Murks erzählt. Ich habe schon zig-fach verschachtelte ForEachs verwendet und es gab nie Probleme. Warum sollte es auch? Es ist ja nur eine andere Schreibweise für den Code, den AlrikvomFluss schon gepostet hat.

 

[chloe]

Sobald du mal selbst eine verkettete Liste implementierst und Iteratoren kennen lernst, wirst du merken, dass in >95% der Fälle die for-each-Schleife zu bevorzugen ist.
Wahrscheinlich hast du deinen Prof nur falsch verstanden ...

 

[Fonce]

Natürlich ist es eine Referenz. Diese for-each Schleife macht nix anderes, als eine Schleife, in der du manuell auf jedes Element zugreifst:

for(int i = 0; i < array.size(); i++){
     Element e = array.get(i);
     tralala....
}

In Java bekommst du zu 99,9 % immer Referenzen zu Gesicht. Für Kopien muss man eigentlich immer explizit einen Klon erzeugen.

So nicht ganz richtig, den die Foreach Schleife ist eine vereinfachte Schreibweise der Iteratorbasierten Schleife und nicht der Indexbasierten

for (Iterator iter = list.iterator(); iter.hasNext();) {
		System.out.println(iter.next());
	}

 

[Bauergiesen]

Eine weitere Möglichkeit ist folgende:

ArrayList<String> liste = new ArrayList<String>();
liste.add("String1");
liste.add("String2");
liste.add("String3");
for(String s : liste) {
System.out.println(s);
}

 

[mercsen]

unser java prof meinte mal man sollte keine foreach schleifen benutzen
weil mehre sachen verlangt werden,
wie das sich das obejtk nicht verändert in der laufzeit
oder auch das in ihnen keine weiteren schleifen möglich sind.

Solange man nicht mit Threads arbeitet wird das ja so oder so nicht vorkommen oder ?
Und wenn dann schmeißt java dir exceptions um die Ohren ^^
Und durch synchronised und nem semaphore auch einfach zu umgehen.
Wenn der Index keine Rolle spielt ist eine for each schleife auf jedenfall mein favorit.

Und wieso sollten im Objekt selber keine weiteren Schleifen sein ?
Denn dann dürfte ja quasi gar kein Objekt mehr zu weiteren schleifen führen, auch nicht wenn du über einen Index iterierst.................
Aber wenn man nun eine Liste mit Listen hat und aus einer der Sublisten nen element haben will, wie soll das ohne noch eine schleife gehen ?

Eine weitere Möglichkeit ist folgende:

Lies nochmal genau den ersten Beitrag ;D

 

[1668mib]

Ich finde foreach sogar guten Stil, weil es weniger Fehlerpotential bietet als die Schleifen von Hand auszuschreiben... sie drückt auch klar aus, was die schleife macht...

man denke nur mal an eine simple for-Schleife, wie oft man den Zähler in einer Zeile hat
for (i = 0; i < ...; i++) {
...
}
es ist hier deutlich leichter nen Fehler reinzumachen dann... (und ja, ich weiß dass foreach der Iterator-Variante entspricht, aber auch hier gibt es mehr Code-Redundanz und vor allem ja die selben Einschränkungen wie mit foreach).

Das ist ja gerade die Eleganz von foreach...

Richtig ist, dass foraech nicht immer sinnvoll ist... aber immer dieses Schwarz- und Weiß-Denken mancher... man muss immer den Kontext beachten, immer schauen, was gerade sinnvoll ist...