Java/IterateThroughHashMapTest.java at main · Eggy115/Java · GitHub

History

173 lines (153 loc) · 5.66 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

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();

}

Java/IterateThroughHashMapTest.java at main · Eggy115/Java · GitHub

Uh oh!

Expand file tree

Breadcrumbs

IterateThroughHashMapTest.java

Latest commit

History

Breadcrumbs

IterateThroughHashMapTest.java

File metadata and controls