def t = (0..10000).flatten()

t[0]=0; t[1]=0; // 0 and 1 are not prime

def L = Math.sqrt(t.size()-1)

( [2,(3..L).step(2)].flatten()).each { n ->
if(t[n]) {
def delta = n==2?1:2;
(((n*n)..(t.size())).step(n*delta)).each {
i -> t[i] = 0
}
}
}

println t.findAll({ it != 0 })

There are same simple things to improve the performance
1. Removing evements from an ArrayList [...] is very expensive. So keep the list size the same and set the the value at an index to zero if the number is not prime.

So if x is not prime then t[x] = 0

2. The outer list outer list has to go over 2 and odd numbers only.

[2, (3..L).step(2)].flatten() will do the trick
(L is sqrt(max_num))
so we get the list [2,3,5,7,9...]

So where does the sqrt come from?

Well… if X is a composite number (non prime) then
X = A*B

let say we always arrange it so that A is always the smallest value such that X = A*B, then the largest value for A can be sqrt(X). (beccause X = sqrt(X)*sqrt(X) )

for the inner loop we don’t have to start fro 2*n if n > 2, because we have already removed all multiples of 2. If n > 3 we don’t have to start from 3*n because we have removed all multiples of 3 and so on.

By that logic we can start from n*n; also n would itself have to be prime, otherwise it already has been removed. So we remove – n*n, n*(n+1), n*(n+2) …

But wait a minute if n is prime and n > 2 the n is also odd; and n+1 must be even (a multiple of 2), but we have removed all those. So we actually need to remove
n*n, n*(n+2), n*(n+4), …

so for n > 2 the step size in the inner loop is 2*n
def t = (0..10000).flatten()
t[0]=0; t[1]=0; // 0 and 1 are not prime
def L = Math.sqrt(t.size())
( [2,(3..L).step(2)].flatten()).each { n ->
if(t[n]) {
def delta = n==2?1:2;
(((n*n)..(t.size())).step(n*delta)).each({i -> t[i] = 0 })
}
}

result = t.findAll({ it != 0 })