bitte, for-Schleife, aus dem Buch erklären

In der for schleife wird als erstes ein wert initialisiert z.B int i = 0; als zweites wird die Bedingung das die Schleife ausgeführt wird festgelegt z.B. i < 10. Als letztes wird festgelegt was mit dem initialisierten wert (i) jeden durchlauf gemacht wird z.B. i++ (i+1).

Beispiel :

int kp = 10;

for (int i = 0; i<kp; i++){
//dieser code wird 10x wiederholt
}

Zitat von waid83

Hallo,
ich bin Java Einsteiger und lese seit einiger Zeit das Buch "Android-Apps entwickeln - für Einsteiger"
Ich bin noch vor dem Kapitel, installation der jdk, aber die Schleifen werden schon vor dem Programmieren erklärt und die for-Schleife ist ungewohnt.
Ich dachte sie baut sich folgender maßen auf:
for(Initialisierung; Zielwert; Schrittweite) {
// Anweisungen
}
Aber das Beispiel im Buch sieht ganz anders aus, so:
for( Item item : inventar){
}

inventar ist überhaupt keine Schrittformel.

Ich hoffe Ihr könnt mir weiterhelfen und dieses Forum wird zu einer guten Lernunterstützung

Alles anzeigen

Es funktionieren beide varianten. Das Beispiel im Buch ist speziell eine sogenannte "for each"-Schleife. Ein Sonderfall der for-Schleifen. Die "for each"-Schleife funktioniert ähnlich.

for(Item itemVariable : listeVonItems) {
    itemVariable.methodenAufruf();
}

Du gibst in die Schleife eine Liste von Items hinein, bei jedem Schleifendurchlauf wird dabei in die itemVariable ein neues Objekt geschoben auf das du innerhalb der Schleife dann zugreifst. Die Schleife wird solang durchlaufen bis jedes Objekt in der listeVonItems einmal in itemVariable gesteckt hat.

Dazu drei Anmerkungen:

Du bekommst aus der Liste das raus, was in der Liste steckt.
Sagst Du der Liste, sie beinhaltet Views und packst 25 Buttons und 1 TextView rein und in der for-each Schleife holst Du alles als Button ab, gibt es beim 26. Objekt eine ClassCastException.

Sammelobjekte sind in Java per Definition veränderlich. Nutzt Du die Schleife um Objekte der Liste hinzuzufügen, zu entfernen oder auszutauschen, dann fliegt Dir das alles um die Ohren. Immer nur lesend in for-each Schleifen zugreifen!

for-each Schleifen sind sicherer als reine for Schleifen, da sie statt irgend einen Wert hochzuzählen über den irgend ein Zugriff geregelt wird sauber das nächste Objekt der Liste zurückliefert. Dafür kostet sie auch viel mehr Ressourcen.
Es muss im obigen Beispiel 26x Speicher reserviert, mit einem Objekt gefüllt und irgendwann von der Garbage Collection wieder weggeräumt werden. Die for Schleife benötigt hingegen erst einmal nur Speicherplatz für einen Integer.

Zitat von Marco Feltmann

for-each Schleifen sind sicherer als reine for Schleifen, da sie statt irgend einen Wert hochzuzählen über den irgend ein Zugriff geregelt wird sauber das nächste Objekt der Liste zurückliefert. Dafür kostet sie auch viel mehr Ressourcen.
Es muss im obigen Beispiel 26x Speicher reserviert, mit einem Objekt gefüllt und irgendwann von der Garbage Collection wieder weggeräumt werden. Die for Schleife benötigt hingegen erst einmal nur Speicherplatz für einen Integer.

Ich überlege gerade, kann man das nicht etwas optimieren? Indem man z.b. die länge des längsten objektes in der implementierung der liste speichert. Bei einer solchen Schleife würde dann einmalig soviel Speicher reserviert werden wie das größte Objekt braucht und alle anderen Objekte werden in dem selben Speicherbereich gespeichert.

Zitat von ChampS

Ich überlege gerade, kann man das nicht etwas optimieren? Indem man z.b. die länge des längsten objektes in der implementierung der liste speichert. Bei einer solchen Schleife würde dann einmalig soviel Speicher reserviert werden wie das größte Objekt braucht und alle anderen Objekte werden in dem selben Speicherbereich gespeichert.

Wir haben eine Garbage Collection. Aber auch bei einem halbautomatischen Reference Count System hättest Du hier ein gravierendes Problem.
Der Schleifenkörper definiert einen eigenen Gültigkeitsbereich. Welchen Automatismus man auch immer verwendet, dieser wird erst beim Verlassen des Gültigkeitsbereichs angesprungen.
Die Automatismen können nicht wissen, ob Du welche Objekte wie lange noch brauchst.
Man fragt die Objekte ja nicht ab, um die CPU zu beschäftigen. (Klappt auch nicht immer, wird oftmals wegoptimiert.)
Meistens tut man etwas mit den Objekten.

Es ist ja insofern schon optimiert, dass man mit Referenzen (Zeiger sagt man ja in Java nicht) statt mit Objektkopien hantiert.
Referenzen haben ja eine definierte geringe Größe, so dass der Speicherunterschied zu vorher nicht so groß ist.

Über den generierten Index aus der for Schleife werden ja auch Objektreferenzen über Instanzmethoden geholt.
Die for-each Schleife packt das lediglich aus dem Schleifenkörper in den Schleifenkopf.

Relevant sind for Schleifen eigentlich nur für prozedurale bzw. funktionale Programmierung, für objektorientierte empfiehlt sich schon die for-each Schleife.

Interessant wurden diese Unterschiede erst durch Apples Swift 3.0, in dem die ursprüngliche for Schleife abgeschafft wurde.

// Swift 2.1
for( int i = 0; i < 10; i++) {
  // läuft ziemlich zügig
}
// Swift 3.0
for (0..<10) {
  // braucht schon etwas länger
}


// Swift 2.1
for( int i = 0; i < 10; i=i+3) {
  // läuft ziemlich zügig
}
// Swift 3.0
for 0.stride(to:10 by:3) {
  // braucht noch länger und das versteht auch keine Sau
}