package java.util;

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    ...
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    ...
}

package java.util;

public class Vector<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    ...
    public synchronized boolean add(E e) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = e;
            return true;
    }
    ...
}

/*
* ArrayList Synchronization
* 
* https://docs.oracle.com/javase/6/docs/api/java/util/Collections.html#synchronizedList(java.util.List)
* @author kimtaeng
*/
public void SomeMethod() {
    List<String> synchronizedList = Collections.synchronizedList(new ArrayList<String>());
    synchronizedList.add("MadPlay");
    synchronizedList.add("MadPlay");
    synchronizedList.add("Kimtaeng");
    
    synchronized(synchronizedList) {
          Iterator i = synchronizedList.iterator(); // Must be in synchronized block
          while (i.hasNext()) {
              foo(i.next());
          }
    }
}

/* LinkedHashSet Class */
public class LinkedHashSet<E> extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
    
    ...
    
    public LinkedHashSet() {
        super(16, .75f, true);
    }
    ...
}
/* If we enter the parent class's constructor super, that is, HashSet's overloaded constructor */
    
public class HashSet<E> extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
    
    ...
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }
    ...
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * TreeSet Example
 *
 * @author kimtaeng
 * created on 2018. 4. 16.
 */
class MadPlay {
    public void collectionTest() {
    
        /* TreeSet sorted in ascending order */
        TreeSet<Integer> treeSet = new TreeSet<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 > o2 ? 1 : (o1 == o2 ? 0 : -1);
            }
        });

        treeSet.add(3); treeSet.add(1); treeSet.add(2);

        Iterator<Integer> iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        /* using Java 8 */
        TreeSet<Integer> java8TreeSet = new TreeSet<>(
                (o1, o2) -> o1 > o2 ? 1 : (o1 == o2 ? 0 : -1)
        );

        java8TreeSet.add(3); java8TreeSet.add(1); java8TreeSet.add(2);

        java8TreeSet.forEach(element -> {
            System.out.println(element);
        });
    }
}

/**
 * TreeSet to SynchronizedSet
 *
 * @author kimtaeng
 * created on 2018. 4. 16.
 */
public class MadPlay {
    public void collectionTest() {
        ...

        /* synchronizedSet */
        Set<Integer> synchronizedSet = Collections.synchronizedSet(treeSet);
        
        ...
    }
}

/* TreeMap Class */
public class TreeMap<K,V> extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable {
    ...
}

/* NavigableMap Interface */
public interface NavigableMap<K,V> extends SortedMap<K,V> {
    ...
}

public void someMethod() {
    TreeMap<Integer, Integer> treeMap = new TreeMap<>(
            (o1, o2) -> o1 > o2 ? 1 : (o1 == o2 ? 0 : -1)
    );
}

/* Hashtable Class */
public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
    
    public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }
}

import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

/**
 * Hashtable, ConcurrentHashMap
 * SynchronizedMap Performance Test
 *
 * @author kimtaeng
 * created on 2018. 4. 16.
 */
class MadPlay {
    private final static int MAX_THREAD_POOL_SIZE = 5;
    private final static int MAX_TEST_COUNT = 5;
    private final static int MAX_OPERATE_COUNT = 100000;

    public static Map<String, Integer> testHashtable = null;
    public static Map<String, Integer> testSyncMap = null;
    public static Map<String, Integer> testConcMap = null;

    public static void collectionPerformTest() throws InterruptedException {
        testHashtable = new Hashtable<>();
        runSomethingTest(testHashtable);

        testConcMap = new ConcurrentHashMap<>();
        runSomethingTest(testConcMap);

        testSyncMap = Collections.synchronizedMap(new HashMap<>());
        runSomethingTest(testSyncMap);
    }

    public static void runSomethingTest(final Map<String, Integer> testTarget) throws InterruptedException {
        System.out.println("Target Class : " + testTarget.getClass());
        long testAverageTime = 0L;

        for (int testCount = 0; testCount < MAX_TEST_COUNT; testCount++) {
            long testStartTime = System.nanoTime(); // Start count
            ExecutorService testExecutor = Executors.newFixedThreadPool(MAX_THREAD_POOL_SIZE);

            // rangeClosed includes the last value when looping
            IntStream.range(0, MAX_THREAD_POOL_SIZE).forEach(count -> testExecutor.execute(() -> {
                // Perform action of putting random values
                for (int opCount = 0; opCount < MAX_OPERATE_COUNT; opCount++) {
                    Integer randomValue = (int) Math.ceil(Math.random() * MAX_OPERATE_COUNT);
                    testTarget.put(String.valueOf(randomValue), randomValue);
                }
            }));

            // End execution. Continues things already executing but doesn't allow new tasks.
            testExecutor.shutdown();

            // Waits until all tasks end after shutdown.
            testExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
            long testEndTime = System.nanoTime(); // End count

            long testTotalTime = (testEndTime - testStartTime) / 1000000L;
            testAverageTime += testTotalTime;
            System.out.println(testTarget.getClass() + "'s Test " + (testCount + 1) + ": " + testTotalTime);
        }
        System.out.println(testTarget.getClass() + "'s average time is " + testAverageTime + "\n");
    }

    public static void main(String[] args) throws InterruptedException {
        collectionPerformTest();
    }
}