# Zählschleife i++ vs. ++i



## java__neuling (29. Jan 2011)

HAllo,

also langsam bin ich wohl total durch den wind...

kann mir jemand mal sagen wie sich folgende schleifen unterscheiden?


```
for (int i=0; i<=5; ++i){
	System.out.println("HALLO1!" + i);
}

for (int i=0; i<=5; i++){
	System.out.println("HALLO2!" + i);
}
```

komischweise bekomme ich bei beiden genau die gleiche ausgabe. bin eigentlich davon ausgegangen, dass die untere schleife einmal mehr durchlaufen wird....ist aber nicht so..

*wahrscheinlich sind mittlerweile 50% der themen durch mir eröffnet wurden* sorry aber ich kann sonst niemanden fragen....

DANKE!


----------



## XHelp (29. Jan 2011)

Alleinstehend macht 
	
	
	
	





```
++i
```
 und 
	
	
	
	





```
i++
```
 kein Unterschied. Das wird erst spannend, wenn die im Kontext auftauchen: 
	
	
	
	





```
b*35+(i++*c)/++i
```
 o.ä.


----------



## nrg (29. Jan 2011)

naja ne for-schleife hat einen initialisierungsteil (int i = 0) eine abbruchsbedingung (i <=5) und einen inkrementierungsteil (i++ bzw ++i).

der initialisierungsteil ist denke klar. der wird ganz am anfang ausgeführt. dann wird dir abbruchsbedingung geprüft. ist diese erfüllt läuft die Schleife los. danach wird inkrementiert (edit: und dann wieder abbruchbedingung geprüft, durchlaufen und inkrementiert. solange bis die abbruchbedingung false liefert).

Schreib den Test mal anders:


```
for (int i=0; i<=5; ){
    System.out.println("HALLO1!" + ++i);
}
 
for (int i=0; i<=5; ){
    System.out.println("HALLO2!" + i++);
}
```

dann wirst du den Unterschied sehen


----------



## java__neuling (29. Jan 2011)

gut danke ich verstehe!

also mit den anzahl der schleifendurchläufe hat ++i und i++ nichts zu tun, oder?
also in beiden fällen läuft die schleife 5 mal.

ich bin immer davon ausgegangen, dass folgende schleife


```
for(int=0; i<=5; i++)
```

folgendermaßen abgearbeitet wird:
1. i auf 0 setzen
2. prufen ob bedinung erfüllt
3. i auf eins setzen
4. schleife durchlaufen


und bei dieser art der schleife


```
for(int=0; i<=5; ++i)
```

folgendes getan wird:

1. i wird zwar auf null gesetzt wird dann aber sofort auf 1 erhöht
2. prüfen der bedinung
3. schleifen durchlauf

aber das ist falsch oder?

DANKE!


----------



## nrg (29. Jan 2011)

java__neuling hat gesagt.:


> aber das ist falsch oder?



ja 

in beiden Fällen:

1: i wird mit 0 initialisiert
2: Bedingung wird überprüft
3: wenn Bedingung erfüllt wird die Schleife durchlaufen
4: i wird um 1 erhöht

den Unterschied konntest du ja grad sehen. Erklären kann man ihn vllt bei einer Initialisierung:


```
int i = 0;
int j = i++;
```

Hier wird zuerst 0 der Variable j zugewiesen und dann i um eins erhöht > j = 0


```
int i = 0;
int j = ++i;
```

Hier wird zuerst i um eins erhöht und erst dann der Wert 1 j zugewiesen > j = 1


----------



## XHelp (29. Jan 2011)

Wie bereits erwähnt. *Nur*

```
i++
```
 oder 
	
	
	
	





```
++i
```
 ist das gleiche.
Fogendes Beispiel:

```
int i=5;
i++;
++i;

int a = i++;
int b = ++i;
```
wird zu:

```
0:   iconst_5 //=5
  1:   istore_1 //i=5
  2:   iinc    1, 1 //i++
  5:   iinc    1, 1 //++i
//oben passiert also 2 mal dasselbe

//int a = i++
  8:   iload_1 //Wert lesen
  9:   iinc    1, 1 //Variablenwert erhöhen
  12:  istore_2 //den zuvor gelesenen Wert (in 8:) abspeichern

//int b = ++i;
  13:  iinc    1, 1 //Variablenwert erhöhen
  16:  iload_1 //erst dann lesen
  17:  istore_3 //in b abspeichern
  18:  return
```


----------



## Landei (29. Jan 2011)

Hier mal eine nützliche Anwendung von [c]i++[/c] (wo [c]++i[/c] nicht funktionieren würde):


```
public class ArrayIterator<T> implements Iterator<T> {
   private final T[] array;
   private int i = 0;  

   public ArrayIterator<T>(T ... array) {
       this.array = array;
   }

   public T next() {
      if(! hasNext()) throw new NoSuchElementException();
      return array[i++]; //es wird array[i] zurückgegeben, aber trotzdem i um 1 erhöht
   }
   //restliche Methoden
}
```


----------

