Java 8 Stream versus For-Loop Performance

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

package streams;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
 * Check whether streams outperform for-loops.
 * See also https://jaxenter.com/java-performance-tutorial-how-fast-are-the-java-8-streams-118830.html
 */
public class StreamPerformance
{
    public static void main(String[] args) {
        System.out.println("Java: "+System.getProperty("java.version"));
        
        StreamPerformance streamPerformance = new StreamPerformance(5000000);
        streamPerformance.performTests(40);
    }
    
    
    private final long[] longArray;
    private final Collection<Long> longList;
    private Long firstMax;
    
    public StreamPerformance(int testDataLength) {
        longArray = createTestArray(testDataLength);
        longList = createTestList(longArray);
    }
    
    private long[] createTestArray(int testDataLength) {
        final long[] longArray = new long[testDataLength];
        for (int i = 0; i < testDataLength; i++)
            longArray[i] = (long) (Math.random() * 1000000d);
        return longArray;
    }
    
    private Collection<Long> createTestList(long[] longArray) {
        final Collection<Long> longList = new ArrayList<Long>(longArray.length);
        for (int i = 0; i < longArray.length; i++)
            longList.add(Long.valueOf(longArray[i]));
        return longList;
    }
    
    public void performTests(final int numberOfTests) {
        long sumStreamWithArray = 0L;
        long sumForLoopWithArray = 0L;
        long sumStreamWithList = 0L;
        long sumForLoopWithList = 0L;
        
        for (int testNumber = 0; testNumber < numberOfTests; testNumber++)   {
            final boolean doForLoop = (testNumber % 2 == 0);
            final boolean doArray = ((testNumber / 2) % 2 == 0);
            
            long millis = performTest(doForLoop, doArray);
            
            if (doForLoop)
                if (doArray)
                    sumForLoopWithArray += millis;
                else
                    sumForLoopWithList += millis;
            else
                if (doArray)
                    sumStreamWithArray += millis;
                else
                    sumStreamWithList += millis;
            
            //System.out.println(testNumber+": "+(doForLoop ? "ForLoop" : "Stream")+" maximum in "+(doArray ? "array" : "list")+" found in "+millis+" millis.");
        }
        
        System.out.println("ForLoop with array millis: "+sumForLoopWithArray);
        System.out.println("Stream with array millis: "+sumStreamWithArray);
        System.out.println("ForLoop with list millis: "+sumForLoopWithList);
        System.out.println("Stream with list millis: "+sumStreamWithList);
        
        final long forLoopSum = sumForLoopWithArray + sumForLoopWithList;
        final long streamSum = sumStreamWithArray + sumStreamWithList;
        System.out.println("ForLoop millis: "+forLoopSum);
        System.out.println("Stream millis: "+streamSum);
        
        System.out.println("ForLoop was "+Math.round((double) streamSum / (double) forLoopSum)+" times faster than Stream.");
    }
    
    private long performTest(boolean doForLoop, boolean doArray)    {
        final long startValue = Long.MIN_VALUE;
        final long before = System.currentTimeMillis();
        final Long max;
        if (doForLoop)
            max = performForLoopTest(doArray, startValue);
        else
            max = performStreamTest(doArray, startValue);
        
        if (firstMax == null)
            firstMax = max;
        else if (firstMax.equals(max) == false)   // assert maximum
            throw new IllegalStateException("Maximum "+max+" was not found correctly, should be "+firstMax);
        
        return (System.currentTimeMillis() - before);
    }

    private Long performForLoopTest(boolean doArray, final long startValue) {
        if (doArray)    {
            long max = startValue;
            for (int i = 0; i < longArray.length; i++)  {
                long l = longArray[i];
                if (l > max)
                    max = l;
            }
            return Long.valueOf(max);
        }
        
        Long max = Long.valueOf(startValue);
        for (Long l : longList)
            if (l > max)
                max = l;
        return max;
    }

    private Long performStreamTest(boolean doArray, final long startValue) {
        if (doArray)    {
            long max = Arrays.stream(longArray).reduce(startValue, Math::max);
            return Long.valueOf(max);
        }
        
        Long max = longList.stream().reduce(Long.valueOf(startValue), Math::max);
        return max;
    }

}