In my java program I have a for-loop looking roughly like this:

```
ArrayList<MyObject> myList = new ArrayList<MyObject>();
putThingsInList(myList);
for (int i = 0; i < myList.size(); i++) { 
     doWhatsoever(); 
}

```

Since the size of the list isn't changing, I tried to accelerate the loop by replacing the termination expression of the loop with a variable.

> 
> My idea was: Since the size of an ArrayList can possibly change while iterating it, the termination expression has to be executed each loop cycle. If I know (but the JVM doesn't), that its size will stay constant, the usage of a variable might speed things up.
> 
> 
> 

```
ArrayList<MyObject> myList = new ArrayList<MyObject>();
putThingsInList(myList);
int myListSize = myList.size();
for (int i = 0; i < myListSize; i++) { 
     doWhatsoever(); 
}

```

However, this solution is slower, way slower; also making myListSize final doesn't change anything to that! I mean I could understand, if the speed didn't change at all; because maybe JVM just found out, that the size doesn't change and optimized the code. But why is it slower?

However, I rewrote the program; now the size of the list changes with each cycle: `if i%2==0`, I remove the last element of the list, else I add one element to the end of the list. So now the `myList.size()` operation has to be called within each iteration, I guessed. 

I don't know if that's actually correct, but still the `myList.size()` termination expression is faster than using just a variable that remains constant all the time as termination expression...

Any ideas why?

Edit (I'm new here, I hope this is the way, how to do it)
My whole test program looks like this:

```
ArrayList<Integer> myList = new ArrayList<Integer>();
for (int i = 0; i < 1000000; i++)
{
    myList.add(i);
}

final long myListSize = myList.size();
long sum = 0;
long timeStarted = System.nanoTime();
for (int i = 0; i < 500; i++)
{
    for (int j = 0; j < myList.size(); j++)
    {
        sum += j;

        if (j%2==0)
        {
            myList.add(999999);
        }
        else
        {
            myList.remove(999999);
        }
    }
}
long timeNeeded = (System.nanoTime() - timeStarted)/1000000;
System.out.println(timeNeeded);
System.out.println(sum);

```

Performance of the posted code (average of 10 executions):
4102ms for myList.size()
4230ms for myListSize

Without the if-then-else statements (so with constant myList size)
172ms for myList.size()
329ms for myListSize

So the speed different of both versions is still there. In the version with the if-then-else parts the percentaged differences are of course smaller because a lot of the time is invested for the add and remove operations of the list.