Why are foreach loops slower in Apex than standard for loop?

Question

Considering the following test class:

@IsTest
private class ProfilingTest {

    private static String TEST_STR = '';

    public static testMethod void testForEachLoop(){
        List<Account> accs = [SELECT Id, Name FROM Account LIMIT 5000];

        for(Account acc : accs){
            acc.Name += TEST_STR;
        }
    }


    public static testMethod void testForLoop(){
        List<Account> accs = [SELECT Id, Name FROM Account LIMIT 5000];

        for(Integer i = 0; i < accs.size(); ++i){
            accs[i].Name += TEST_STR;
        }
    }


    public static testMethod void testImprovedForLoop(){
        List<Account> accs = [SELECT Id, Name FROM Account LIMIT 5000];
        Integer size = accs.size();

        for(Integer i = 0; i < size; ++i){
            accs[i].Name += TEST_STR;
        }
    }


    public static testMethod void testWhileLoop(){
        List<Account> accs = [SELECT Id, Name FROM Account LIMIT 5000];
        Integer size = accs.size();
        Integer i = 0;

        while(i < size){
            accs[i].Name += TEST_STR;
            ++i;
        }
    }
}

And the test result :

Is there a particular reason why standard for loop is faster in Apex than for-each loop? What I think is it may be because the 'i' knows which element to pick and for every iteration the size of the list gets smaller and smaller.

But I need some more explanation as why are we seeing huge performance advantage when using standard for loop ?

Answer 1

It's because for each loops end up using an Iterator, which is inherently slower than a normal for loop. Here's what it might compile to internally:

Iterator<Object> iter = source.iterator();
while(iter.hasNext()) {
  Object next = iter.next();
  forLoopBody.yield(next);
}

As you can see, it has to initialize an extra object, and has to do a bit more work than a straight for loop (calling not just one, but two functions for every value in the loop). This effect is multiplied when you have a for each loop nested inside another, as it has to create a new Iterator for every value in the outer loop, even if the Iterator is empty.

I don't have the exact timing of this, as it is a small, but noticeable difference. There are several losses, including having to allocate an entire object instead of a simple variable, and the overhead of calling methods.

For now, while for each loops are easier to read, they are definitely the worst in performance, especially compared to a pre-initialized for loop:

for(Integer index = 0, size = someList.size(); index < size; index++) {

---

As other answers noted, you may be also be seeing database latency. Here's an updated version that doesn't use the database:

@isTest class q227272 {
    private static String TEST_STR = '';

    static Account[] createAccounts() {
        Account[] records = new Account[0];
        for(Integer i = 0; i < 5000; i++) {
            records.add(new Account(Name=''+i));
        }
        return records;
    }
    public static testMethod void testForEachLoop(){
        List<Account> accs = createAccounts();
        Long start = DateTime.now().getTime();

        for(Account acc : accs){
            acc.Name += TEST_STR;
        }
        System.assert(false, DateTime.now().getTime()-start);
    }


    public static testMethod void testForLoop(){
        List<Account> accs = createAccounts();
        Long start = DateTime.now().getTime();

        for(Integer i = 0; i < accs.size(); ++i){
            accs[i].Name += TEST_STR;
        }
        System.assert(false, DateTime.now().getTime()-start);
    }


    public static testMethod void testImprovedForLoop(){
        List<Account> accs = createAccounts();
        Long start = DateTime.now().getTime();
        Integer size = accs.size();

        for(Integer i = 0; i < size; ++i){
            accs[i].Name += TEST_STR;
        }
        System.assert(false, DateTime.now().getTime()-start);
    }


    public static testMethod void testWhileLoop(){
        List<Account> accs = createAccounts();
        Long start = DateTime.now().getTime();
        Integer size = accs.size();
        Integer i = 0;

        while(i < size){
            accs[i].Name += TEST_STR;
            ++i;
        }
        System.assert(false, DateTime.now().getTime()-start);
    }
}

---

After ignoring the effects of the database, we get output like this:

testForEachLoop      93ms
testForLoop          104ms
testImprovedForLoop  73ms
testWhileLoop        80ms

Which still shows that the improved for loop is the best option, but the testForLoop takes the worst place; calling size() each iteration results in undesirable performance, while caching the size() call is the best option.

Answer 2

Great to see a question with concrete data included.

I'm surprised the difference is so large. I strongly suggest you re-order the methods and see if that makes a difference. You have the query within your timings and the first query will cache the data - at least at the Oracle level - and so subsequent ones will be quicker.

(I don't see a SeeAllData=true so where are the Accounts coming from? If you are using a very low API number so that isn't needed, it would be worth moving to the latest API number.)

I'd like to see this case included too:

public static testMethod void testSoqlForEachLoop(){
    for(Account acc : [
            SELECT Id, Name
            FROM Account
            LIMIT 5000
            ]){
        acc.Name += TEST_STR;
    }
}

which is a pattern I use all the time and aims to be kind to heap space usage.

I favour clean code over (small) performance differences. If code needs tuning to the level of changing from one closely equivalent algorithm to another, you are probably bumping up to and will exceed the CPU governor limit at some point in the future when more code has to be added.

A key thing is to avoid exponential time growth algorithms and instead refactor to algorithms where the time growth is linear e.g. use a map instead of a nested loop. See e.g. Fixing a common cause of System.LimitException: Apex CPU time limit exceeded.

Answer 3

Interesting question. My random guess would be because you initialize a new object(OO talk here) in a foreach loop and do not do it in the other ones.

If you try the same test class but with initializing new Accounts inside your for loops, you will probably have more accurate data.

For example:

public static testMethod void testForLoop(){
    List<Account> accs = [SELECT Id, Name FROM Account LIMIT 5000];

    for(Integer i = 0; i < accs.size(); ++i){
        Account a = accs.get(i);
        a.Name += TEST_STR;
    }
}

I will also try it myself when I have time.

Answer 4

Your test methodology and result are flawed because of the database caching (connection caching and query caching) that takes place. The first test to run will always be the slowest to run because loading the data takes way more time than iterating on results.

The only way to properly compare these iteration methods is to exclude the query from the test or to defeat the caching. I suggest that you create a helper method that returns a list of accounts that you build locally yourself.