AsyncRandomPrimeNumbersApp.java

import java.util.*;
import java.util.concurrent.*;

import static java.lang.System.out;

public class AsyncRandomPrimeNumbersApp {

    public static void main(String[] args) throws Exception {

        final List<PrimeAvgTask> tasks = new ArrayList<>();
        final int by    = 100;
        final int limit = 1000 - by;

        for (int from = 0; from <= limit; from += by)
            tasks.add(new PrimeAvgTask(from, from + by));

        final ExecutorService executor = Executors.newFixedThreadPool(tasks.size());

        print(executor.invokeAll(tasks));

        executor.shutdown();
    }

    static void print(List<Future<Result>> result) throws Exception {

        final List<Integer> numbers = new ArrayList<>();
        final List<Integer> primes  = new ArrayList<>();
        int sum = 0;

        for (final Future<Result> f: result) {
            final Result r = f.get();
            numbers.addAll(r.numbers);
            primes.addAll(r.primes);
            sum += r.average;
        }

        out.println("Numbers: ");

        numbers.stream()
        .parallel()
        .map(n -> String.format(primes.contains(n) ? "[%s], " : "%s, ", n))
        .forEach(out::print);

        out.println(String.format("\nAverage %s", Result.div(sum, result.size())));
    }

}

class Result {

    public List<Integer> numbers;
    public List<Integer> primes ;
    public double        average;

    public Result(final List<Integer> n, final List<Integer> p, final double avg) {
        numbers = n;
        primes  = p;
        average = avg;
    }

    public static Integer div(final Integer n, final Integer d) {
        return d == 0 ? 0 : n / d;
    }
}

class PrimeAvgTask implements Callable<Result> {

    private final ThreadLocalRandom gen = ThreadLocalRandom.current();

    private final Integer from;
    private final Integer to;

    public PrimeAvgTask(final Integer f, final Integer t) {
        from = f;
        to   = t;
    }

    @Override
    public Result call() throws Exception {
        return Calc();
    }

    private Result Calc() {
        final List<Integer> numbers = new ArrayList<>();
        final List<Integer> primes  = new ArrayList<>();
        int sum = 0;

        for (int n = from; n <= to; n++) {
            final int num = genNum();
            numbers.add(num);

            if (isPrime(num)) {
              primes.add(num);
              sum += num;
            }
        }

        return new Result(numbers, primes, Result.div(sum, primes.size()));
    }

    private int genNum() {
        return gen.nextInt(100 - 1) + 1;
    }

    private boolean isPrime(final int n) {
        int c = 2;
        int d = 2;
        while (c == 2 && d < n) {
          if ((n % d) == 0)
            c++;
          d++;
        }
        return c == 2;
    }

}