public class Main {
    public static void main(final String... args) {
        MyBenchMark benchMark = new EnumMapClass();
//        MyBenchMark benchMark = new HashMapClass();

        MyBenchMarkRunner benchMarkRunner = new MyBenchMarkRunner(benchMark);
        benchMarkRunner.run();
    }
}

public class MyBenchMarkRunner {

    private final MyBenchMark benchMark;

    private static final int NUMBER_OF_REPETITIONS = 10;

    public MyBenchMarkRunner(MyBenchMark benchMark) {
        this.benchMark = benchMark;
    }

    public void run() {
        long resultSum = 0L;
        try {
            for (int i = 0; i < NUMBER_OF_REPETITIONS; i++) {
                long start = System.currentTimeMillis();
                benchMark.test();
                long elapsedTime = System.currentTimeMillis() - start;
                out.printf("elapsedTime :  %d ms \n", elapsedTime);
                resultSum += elapsedTime;
            }
        } catch (RuntimeException e) {
            out.println(e.getMessage());
        }
        double avgTime = (double) resultSum / NUMBER_OF_REPETITIONS;
        out.printf("\n %d회 반복 평균 시간 :  %.2f ms \n", NUMBER_OF_REPETITIONS, avgTime);
    }

}

public interface MyBenchMark {
    int NUMBER_OF_TRIALS = 10_000_000;
    void test() throws RuntimeException;
}

public class EnumMapClass implements MyBenchMark {

    private EnumMap<MyEnum, Integer> map;

    public EnumMapClass() {
        map = new EnumMap<>(MyEnum.class);
        for (MyEnum value : MyEnum.values()) {
            map.put(value, value.num);
        }
    }

    @Override
    public void test() throws RuntimeException {
        final int myEnumSize = MyEnum.values().length;
        for (int i = 0; i < NUMBER_OF_TRIALS / myEnumSize; i++) {
            for (MyEnum value : MyEnum.values()) {
                map.get(value);
            }
        }
    }

    @RequiredArgsConstructor
    private enum MyEnum {
        N1(1), N2(2), N3(3), N4(4), N5(5), N6(6), N7(7), N8(8), N9(9), N10(10);
        private final int num;
    }
}

public class HashMapClass implements MyBenchMark {

    private Map<Integer, Integer> map;

    public HashMapClass() {
        map = new HashMap<>();
        IntStream.rangeClosed(1, NUMBER_OF_TRIALS).forEach(value -> map.put(value, value));
    }

    @Override
    public void test() {
        map();
    }

    private void map() {
        IntStream.rangeClosed(1, NUMBER_OF_TRIALS).forEach(value -> map.get(value));
    }
}