# Java for Schleife performance unterschiede



## meckiebro (4. Januar 2011)

Hallo zusammen normal nutze ich mehrere Varianten bei for schleifen und mich würde mal interessieren was da eigentlich optimaler ist von der Geschwindigkeit oder ob das wurst ist.

Es geht eigentlich immer darum eine Liste etc. zu durchlaufen.
Ich schreibe mal nur den Kopf hin


```
ArrayList<Integer> list;
```

V1.

```
for(int i = 0; i < list.size(); i++)
```

V2.

```
for(int elem : list)
```

V3.

```
for(Iterator<Integer> it = list.iterator(); it.hasNext();)
```

Mehr fällt mir jetzt nicht ein. 

Liebe Grüße
Meckie


----------



## tkdmatze (4. Januar 2011)

Laut 
http://java-persistence-performance.blogspot.com/2010/12/what-is-faster-jvm-performance.html
v1


----------



## meckiebro (4. Januar 2011)

Wow Tatsache das überrascht mich ein wenig. Dachte gerade dieses list.get(i) ist nicht so gut. Aber ok. Ja dann.
Wobei ich glaube aber das dann die Remove Methode über den Iterator schneller und sicherer war. Irgendwas war da. Ist alles schon so lange her. Naja.

Dank dir


----------



## tkdmatze (4. Januar 2011)

Hoffe du hast auch das Pardoxon der deprecated HashTable gesehen,
das hat mich mehr überrascht, dass deprecated Klassen schneller sind als die neuen.

Bei den anderen irgendwie ein bissel klar,
Iterator muss erzeugt werden, hasnext ist 'ne boolean abfrage....

size() ist eine Klassenvariable, die einfach nur abgefragt wird.


----------



## meckiebro (4. Januar 2011)

Hui seh ich das richtig? Ist LinkedList schneller als ArrayList? war mir auch neu.
Muss ja alles umschreiben hier...


----------



## zerix (4. Januar 2011)

Hallo.

Jede Liste hat ihre Stärken und ihre Schwächen. Beim normalen durchiterieren ist die LinkedList am schnellsten. Wenn du aber immer an bestimmte Punke in der Liste springen musst, also bestimmte Positionen der Liste möchtest, ist die ArrayList schneller. 

Gruß

Sascha


----------



## tkdmatze (4. Januar 2011)

du musst das schon richtig lesen
+ = besser 
- = schlechter

LinkedList ist besser als Vector und schlechter als Arraylist bei weniger Einträgen
Arraylist ist besser als Vector und LinkedList bei mehr Einträgen


----------



## Anime-Otaku (10. Januar 2011)

Es kommt auch stark darauf an, was du mit der Liste/Map oder was auch immer machen willst. Willst du bestimmte Positionen aus einer Liste löschen ist die LinkedList vlt die Qual der Wahl. Aber vielleicht passiert das nur in einem vernachlässigbarem Ausnahmefall, dann kann wieder eine andere Implementierung interessant werden.

Zu Topic:
V2 und V3 sind beim Eclipse-Compiler identisch(afaik). Foreach benutzt bei ArrayList der Iterator.

Zu:
for(int i = 0; i < list.size(); i++)

Im For each von _Arrays _wird die Größe als Laufvariable gespeichert, damit hier noch ein paar Nanosekunden gespart werden.


----------



## RoCMe (10. Januar 2011)

In diesem Zusammenhang noch mal eine Warnung vor der Index-Variante im Zusammenspiel mit LinkedList:

Um das i-te Element einer verketteten Liste zu bekommen, muss vom Head-Element ausgehend i-mal die next-Methode aufgerufen werden. In einer LinkedList ist die Zugriffszeit auf einen bestimmten Index also keineswegs konstant, sondern kann - abhängig vom betrachteten Index - sehr groß werden.

Und das führt dann bei Iterationen a la


```
List<MyClass> list = new LinkedList<MyClass>();
...
for (int i=0;i<list.size();i++) {
bearbeite( list.get(i) );
...
}
```
zu Laufzeiten jenseits von Gut und Böse, wenn die Liste groß wird


----------



## Reilif (28. Februar 2011)

Soweit ich mich erinnern kann ist die Komplexität bei allen O. Aber wenn man sich das detailierter anguckt, sieht man das die eine version in kleineren Bereichen schneller ist und die anderen in höheren Zahlenbereichen. Könnte man ja mal ausrechnen


----------

