1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
|
/**
*
*/
package de.fhswf.in.inf.java1.aufgabe6;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Vector;
/**
* Class that benchmarks List implementations.
*
* @author $Author: $
* @version $Revision: $, $Date: $ UTC
*/
public final class ListBenchmark
{
private static final Integer TESTOBJ = new Integer(214);
/**
* Prevents instantiation of the utility class.
*
*/
private ListBenchmark()
{
}
/**
* Starts a benchmark of different Lists and different test cases.
*
*/
public static void startBenchmark()
{
final int times = 100000;
benchmarkGrouping("ArrayList", new ArrayList<Integer>(times), times);
benchmarkGrouping("Vector", new Vector<Integer>(times), times);
benchmarkGrouping("LinkedList", new LinkedList<Integer>(), times);
}
/**
* Groups the 3 different benchmark versions together.
*
* @param variant
* Name of the list type.
* @param list
* The list which will be benchmarked.
* @param times
* How often will be inserted.
*/
private static void benchmarkGrouping(String variant, List<Integer> list,
int times)
{
System.out.print(variant + " am Anfang: ");
System.out.println(benchmarkAtBeginning(list, times) + " ms");
System.out.print(variant + " am Ende: ");
System.out.println(benchmarkAtEnding(list, times) + " ms");
System.out.print(variant + " zufälliger Index: ");
System.out.println(benchmarkAtRandom(list, times) + " ms");
}
/**
* Inserts new value at the beginning of the list.
*
* @param list
* List to be tested.
* @param times
* How many inserts are done.
* @return Time in milliseconds that the action took.
*/
private static long benchmarkAtBeginning(List<Integer> list, int times)
{
long start = System.currentTimeMillis(); // Gets current time in µs
for (int i = 0; i < times; i++)
{
list.add(0, TESTOBJ);
}
return (System.currentTimeMillis() - start); // Returns runtime
}
/**
* Inserts new value at the end of the list.
*
* @param list
* List to be tested.
* @param times
* How many inserts are done.
* @return Time in milliseconds that the action took.
*/
private static long benchmarkAtEnding(List<Integer> list, int times)
{
long start = System.currentTimeMillis(); // Gets current time in µs
for (int i = 0; i < times; i++)
{
list.add(TESTOBJ);
}
return (System.currentTimeMillis() - start); // Returns runtime
}
/**
* Inserts new value at a random index of the list.
*
* @param list
* List to be tested.
* @param times
* How many inserts are done.
* @return Time in milliseconds that the action took.
*/
private static long benchmarkAtRandom(List<Integer> list, int times)
{
int[] randVal = new int[times];
Random rand = new Random();
for (int i = 0; i < randVal.length; i++)
{
randVal[i] = rand.nextInt(list.size() + i + 1);
}
long start = System.currentTimeMillis(); // Gets current time in µs
for (int i = 0; i < times; i++)
{
list.add(randVal[i], TESTOBJ);
}
return (System.currentTimeMillis() - start); // Returns runtime
}
}
|
