package other_examples;

import org.apache.commons.collections4.IterableMap;

import org.apache.commons.collections4.MapIterator;

import org.apache.commons.collections4.map.HashedMap;

import org.eclipse.collections.api.map.MutableMap;

import org.eclipse.collections.impl.map.mutable.UnifiedMap;

import org.openjdk.jmh.annotations.*;

import org.openjdk.jmh.runner.Runner;

import org.openjdk.jmh.runner.RunnerException;

import org.openjdk.jmh.runner.options.Options;

import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.io.IOException;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import java.util.stream.Collector;

import java.util.stream.Collectors;

/**

* Created by vvedenin on 2/21/2016.

*/

@State(Scope.Benchmark)

public class IterateThroughHashMapTest {

private final static Integer SIZE = 100;

@Param({"100","1000"})

public int size;

private Map<Integer, Integer> map = new HashMap<>(SIZE);

/** 1. Using iterator and Map.Entry **/

@Benchmark

public long test1_UsingWhileAndMapEntry() throws IOException {

long i = 0;

Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();

while (it.hasNext()) {

Map.Entry<Integer, Integer> pair = it.next();

i += pair.getKey() + pair.getValue();

}

return i;

}

/** 2. Using foreach and Map.Entry **/

@Benchmark

public long test2_UsingForEachAndMapEntry() throws IOException {

long i = 0;

for (Map.Entry<Integer, Integer> pair : map.entrySet()) {

i += pair.getKey() + pair.getValue();

}

return i;

}

/** 3. Using foreach from Java 8 **/

@Benchmark

public long test3_UsingForEachAndJava8() throws IOException {

final long[] i = {0};

map.forEach((k, v) -> i[0] += k + v);

return i[0];

}

/** 4. Using keySet and foreach **/

@Benchmark

public long test4_UsingKeySetAndForEach() throws IOException {

long i = 0;

for (Integer key : map.keySet()) {

i += key + map.get(key);

}

return i;

}

/** 5. Using keySet and iterator **/

@Benchmark

public long test5_UsingKeySetAndIterator() throws IOException {

long i = 0;

Iterator<Integer> itr2 = map.keySet().iterator();

while (itr2.hasNext()) {

Integer key = itr2.next();

i += key + map.get(key);

}

return i;

}

/** 6. Using for and Map.Entry **/

@Benchmark

public long test6_UsingForAndIterator() throws IOException {

long i = 0;

for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) {

Map.Entry<Integer, Integer> entry = entries.next();

i += entry.getKey() + entry.getValue();

}

return i;

}

/** 7. Using Java 8 Stream Api **/

@Benchmark

public long test7_UsingJava8StreamApi() throws IOException {

final long[] i = {0};

map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());

return i[0];

}

/** 8. Using Java 8 Stream Api parallel **/

@Benchmark

public long test8_UsingJava8StreamApiParallel() throws IOException {

final long[] i = {0};

map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());

return i[0];

}

/** 9. Using Apache IterableMap **/

private IterableMap<Integer, Integer> iterableMap = new HashedMap<>(SIZE);

@Benchmark

public long test9_UsingApacheIterableMap() throws IOException {

long i = 0;

MapIterator<Integer, Integer> it = iterableMap.mapIterator();

while (it.hasNext()) {

i += it.next() + it.getValue();

}

return i;

}

/** 10. Using MutableMap of Eclipse (CS) collections **/

private MutableMap<Integer, Integer> mutableMap = UnifiedMap.newMap(SIZE);

@Benchmark

public long test10_UsingEclipseMap() throws IOException {

final long[] i = {0};

mutableMap.forEachKeyValue((key, value) -> {

i[0] += key + value;

});

return i[0];

}

/** 11. Using Java 8 Stream Api 2 **/

@Benchmark

public long test11_UsingJava8StreamApi2() throws IOException {

return map.entrySet().stream().mapToLong(e -> e.getKey() + e.getValue()).sum();

}

/** 12. Using Java 8 Stream Api parallel 2 **/

@Benchmark

public long test12_UsingJava8StreamApiparallel2() throws IOException {

return map.entrySet().parallelStream().mapToLong(e -> e.getKey() + e.getValue()).sum();

}

@TearDown(Level.Iteration)

public void tearDown() {

map = new HashMap<>(size);

iterableMap = new HashedMap<>(size);

mutableMap = UnifiedMap.newMap(size);

for (int i = 0; i < size; i++) {

map.put(i, i);

mutableMap.put(i, i);

iterableMap.put(i, i);

}

}

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

Options opt = new OptionsBuilder()

.include(IterateThroughHashMapTest.class.getSimpleName())

.timeUnit(TimeUnit.MICROSECONDS)

.warmupIterations(3)

.measurementIterations(5)

.param("size","100",/*"500","900","1300","1700","2100","2500","5000","10000","15000","20000","25000" ,*/ "30000")

.forks(1)

.mode(Mode.AverageTime)

.build();

new Runner(opt).run();

}

}