# Loops performance in Groovy

## Introduction

In the 2018 Advent of Code challenged I solved all the puzzles in Groovy. It is pretty obvious, that choosing good data structure is the most important to obtain performant solution. However, the way we iterate over those structures is also very significant, at least when using Groovy.

## Measuring performance

I want to measure how long it takes to sum some numbers. For testing performance of loops I prepared a small function that simply sums some numbers:

void printAddingTime(String message, long to, Closure<Long> adder) { LocalTime start = LocalTime.now() long sum = adder(to) println("$message: $sum calculated in ${Duration.between(start, LocalTime.now()).toMillis()} ms") }

Pseudo code for summing functions is below:

for i = 1 to n for j = 1 to n sum += i * j end end

## Loops types

Let’s implement the summing function in various ways.

`collect`

and `sum`

First loop type is to use built-in (by Groovy) function `collect`

and `sum`

on collections (`Range`

it this example):

(1..n).collect { long i -> (1..n).collect { long j -> i * j }.sum() }.sum()

`each`

Next, let’s write the same function using `each`

built-in function on collections (`Range`

it this example) and then add results to accumulator variable:

long sum = 0 (1..n).each { long i -> (1..n).each { long j -> sum += i * j } } return sum

`times`

Now instead of using `each`

we could use the function `times`

built-in on `Number`

by Groovy:

long sum = 0 n.times { long i -> n.times { long j -> sum += (i + 1)*(j+1) } } return sum

We have to add `1`

to `i`

and `j`

because times generates numbers from `0`

to `n`

exclusive.

`LongStream`

with `sum`

Java 8 came with a new feature – streams. One example of streams is `LongStream`

. Fortunately, it has `sum`

built-in function, which we can use:

LongStream.range(0, n).map { i -> LongStream.range(0, n).map { j -> (i + 1) * (j + 1) }.sum() }.sum()

`LongStream`

generates numbers in the same way as `times`

function, so we also have to add `1`

to `i`

and `j`

here.

`LongStream`

with manual sum

Instead of `sum`

function on `LongStream`

, we can add all numbers manually:

long sum = 0 LongStream.range(0, n).forEach { i -> LongStream.range(0, n).forEach { j -> sum += (i + 1) * (j + 1) } } return sum

`while`

Of course since Groovy inherits from Java a big part of its syntax, we can use the `while`

loop:

long sum = 0 long i = 1 while(i <= n){ long j = 1 while(j <= n){ sum+= i*j ++j } ++i } return sum

`for`

As we can use `while`

, we can also use `for`

loop in Groovy:

long sum = 0 for (long i = 1; i <= n; ++i) { for (long j = 1; j <= n; ++j) { sum += i * j } } return sum

## Results

My tests I run on Java `1.8`

and Groovy `2.5.5`

. Script `loops.groovy`

was fired using bash script:

#!/bin/sh for x in 10 100 1000 10000 100000; do echo $x groovy loops.groovy $x echo done

Values are in milliseconds

Loop n | 10 | 100 | 1000 | 10000 | 100000 |
---|---|---|---|---|---|

`collect` + `sum` |
7 | 22 | 216 | 16244 | 1546822 |

`each` |
12 | 17 | 118 | 7332 | 706781 |

`times` |
2 | 10 | 109 | 8264 | 708684 |

`LongStream` + `sum` |
7 | 17 | 127 | 7679 | 763341 |

`LongStream` + manual sum |
18 | 35 | 149 | 6857 | 680804 |

`while` |
8 | 20 | 103 | 3166 | 301967 |

`for` |
7 | 10 | 25 | 359 | 27966 |

As you can spot, for small amount of iterations using built-in Groovy functions is good enough, but for much bigger amount of iterations we should use `while`

or `for`

loops like in plain, old Java.

## Show me the code

Code for those examples are available here. You can run those examples on your machine and check performance on your own.

Published on Java Code Geeks with permission by Dominik Przybysz, partner at our JCG program. See the original article here: Loops performance in Groovy
Opinions expressed by Java Code Geeks contributors are their own. |