/* package whatever; // don't place package name! */
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
 
 class ArrayBenchmark {
  public static void main(String[] args) {
    List<Integer> arraySizes = Arrays.asList(1, 5, 10, 20,50,60,80, 100,200,500, 1000,2000, 5000,10000);
    int numberOfSamples = 200;
    Map<Integer, List<int[]>> arraysBySize = new TreeMap<>();
    Map<Integer, List<Long>> runTimesBySize = new TreeMap<>();
    arraySizes.forEach(size -> {
      System.out.printf("Initializing arrays for size %d%n", size);
      List<int[]> arrays = new ArrayList<>();
      List<Long> runtimes = new ArrayList<>();
      for (int j = 0; j < numberOfSamples; j++) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
          arr[i] = i;
        }
        arrays.add(arr);
      }
      arraysBySize.put(size, arrays);
      runTimesBySize.put(size, runtimes);
    });
 
    arraysBySize.entrySet().forEach(entry -> {
      int size = entry.getKey();
      System.out.printf("Running Benchmark for size %d%n", size);
      List<int[]> listOfArrays = entry.getValue();
      List<Long> runtimeList = runTimesBySize.get(size);
      for (int i = 0; i < numberOfSamples; i++) {
        int[] array = listOfArrays.get(i);
        int[] target = new int[array.length];
        long before = System.nanoTime();
        System.arraycopy(array, 0, target, 0, array.length);
        long after = System.nanoTime();
        runtimeList.add(after - before);
      }
 
    });
 
    System.out.println("Results:");
    System.out.println();
 
    runTimesBySize.forEach((size, runtimes) -> {
 
      System.out.printf("Array size: %d%n", size);
      System.out.printf("Total nanos: %d%n", runtimes.stream().mapToLong(Long::longValue).sum());
      System.out.printf("Average nanos: %s%n",
        runtimes.stream().mapToLong(Long::longValue).average().getAsDouble());
 
      System.out.println();
    });
  }
}

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