TimeTest.java

import utils.TimeUtil;
import xyz.micrusa.structures.*;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class TimeTest {
    private static final int TEST_COUNT = 10000;
    private static final int INITIAL_CAPACITY = 100;
    private static final double LOAD_FACTOR = 0.75;

    private static final TimeTestClass[] TIME_TEST_CLASSES = new TimeTestClass[]{
            new TimeTestClass<>("warmup", new DynamicArray<Integer>(INITIAL_CAPACITY, DynamicArray.ResizeStrategy.DOUBLING), DynamicArray::add, (a, i) -> a.remove(0)),
            new TimeTestClass<>("DynamicArray (DOUBLING)", new DynamicArray<Integer>(INITIAL_CAPACITY, DynamicArray.ResizeStrategy.DOUBLING), DynamicArray::add, (a, i) -> a.remove(0)),
            //new TimeTestClass<>("DynamicArray (INCREMENT)", new DynamicArray<Integer>(INITIAL_CAPACITY, DynamicArray.ResizeStrategy.INCREMENTAL), DynamicArray::add, (a, i) -> a.remove(0)),
            new TimeTestClass<>("DynamicArrayStack", new DynamicArrayStack<Integer>(), DynamicArrayStack::push, (a, i) -> a.pop()),
            new TimeTestClass<>("LinkedQueue", new LinkedQueue<Integer>(), LinkedQueue::queue, (a, i) -> a.dequeue()),
            new TimeTestClass<>("LinkedStack", new LinkedStack<Integer>(), LinkedStack::push, (a, i) -> a.pop()),
            new TimeTestClass<>("SimpleHashMap", new SimpleHashMap<Integer, Integer>(INITIAL_CAPACITY, LOAD_FACTOR), (a, i) -> a.put(i, i), SimpleHashMap::remove)

    };

    public static void main(String[] args) {
        Map<String, Long> addTimes = new HashMap<>();
        Map<String, Long> removeTimes = new HashMap<>();


        for(TimeTestClass timeTestClass : TIME_TEST_CLASSES) {
            long addTime = TimeUtil.time(() -> {
                for(int i = 0; i < TEST_COUNT; i++) {
                    timeTestClass.add(i);
                }
            });

            long removeTime = TimeUtil.time(() -> {
                for(int i = 0; i < TEST_COUNT; i++) {
                    timeTestClass.remove(i);
                }
            });

            addTimes.put(timeTestClass.name(), addTime);
            removeTimes.put(timeTestClass.name(), removeTime);
        }

        double minTime = Math.min(addTimes.values().stream().mapToLong(Long::longValue).min().getAsLong(), removeTimes.values().stream().mapToLong(Long::longValue).min().getAsLong());

        System.out.printf("%-30s | %-18s | %-18s | %-18s | %-18s%n", "Class", "Add Time (ns)", "Remove Time (ns)", "Add Time / Min", "Remove Time / Min");
        addTimes.keySet().stream().sorted().map(name -> {
            long addTime = addTimes.get(name);
            long removeTime = removeTimes.get(name);
            return String.format("%-30s | %-18d | %-18d | %-18f | %-18f", name, addTime, removeTime, addTime / minTime, removeTime / minTime);
        }).forEach(System.out::println);
    }

    private record TimeTestClass<T>(String name, T instance, BiConsumer<T, Integer> addMethod, BiConsumer<T, Integer> removeMethod) {
        private void add(int i) {
            addMethod.accept(instance, i);
        }

        private void remove(int i) {
            removeMethod.accept(instance, i);
        }
    }
}