我们进行了附加测试。结果一致表明，通过索引访问数组比通过密钥访问地图快10倍。这个数量级的差异让我们感到惊讶。
我们对Map的关键是java.lang.String ...是计算Map键的java.lang.String.hashcode（）实现的独家原因吗？在附加的代码中，我只使用了一个键
java.lang.String key = 1;
在这种情况下，不是编译器/运行时缓存吗？或者它是否会在每次调用时重新计算？
感谢您的任何见解。
public class PerfTest {
static java.util.HashMap<String, Double> map;
static Double[] array = {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
static long nTimes = 1000000;
static{
map = new java.util.HashMap<String, Double>();
map.put("1", new Double(1));
map.put("2", new Double(2));
map.put("3", new Double(3));
map.put("4", new Double(4));
map.put("5", new Double(5));
map.put("6", new Double(6));
map.put("7", new Double(7));
map.put("8", new Double(8));
map.put("9", new Double(9));
map.put("10", new Double(10));
}
public static void main(String[] args){
PerfTest tester = new PerfTest();
long timeInMap = tester.testHashMap();
long timeInArray = tester.testArray();
System.out.println("Corrected time elapsed in map(in seconds): "
+ (timeInMap)/1000000000.0);
System.out.println("Corrected time elapsed in array(in seconds): "
+ (timeInArray)/1000000000.0);
}
private long testHashMap(){
int sz = map.size();
long startTime = System.nanoTime();
String key = "1";
for (int i=0; i <nTimes; i++){
double sum = 0;
for (int j =1; j<=sz; j++){
sum += map.get(key);
}
}
return (System.nanoTime() - startTime);
}
private long testArray(){
long startTime = System.nanoTime();
for (int i=0; i <nTimes; i++){
double sum = 0;
for (int j=0; j< array.length; j++) {
sum += array[j];
}
}
return (System.nanoTime() - startTime);
}
}
答案 0 :(得分：6)
使用Java的系统时间不是获得真正基准测试的好方法。我重构了你的代码以使用Google Caliper（它可以加热JVM等等）......并且发现了类似的结果。评论者正确指出我原来的版本并不好，大部分时间都是System.out.println次来电。
就像我说的那样，编写基准很难。下面更新的是新的正确版本。
0% Scenario{vm=java, trial=0, benchmark=HashMap} 51.04 ns; σ=0.22 ns @ 3 trials
50% Scenario{vm=java, trial=0, benchmark=Array} 4.05 ns; σ=0.01 ns @ 3 trials
benchmark ns linear runtime
HashMap 51.04 ==============================
Array 4.05 ==
import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;
public class PerfTest {
public static double hashNum = 0;
public static double arrayNum = 0;
public static class PerfBenchmark extends SimpleBenchmark {
static java.util.HashMap<String, Double> map;
static Double[] array = {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
static{
map = new java.util.HashMap<String, Double>();
map.put("1", new Double(1));
map.put("2", new Double(2));
map.put("3", new Double(3));
map.put("4", new Double(4));
map.put("5", new Double(5));
map.put("6", new Double(6));
map.put("7", new Double(7));
map.put("8", new Double(8));
map.put("9", new Double(9));
map.put("10", new Double(10));
}
public void timeHashMap(int nTimes){
int sz = map.size();
String key = "1";
for (int i=0; i <nTimes; i++){
double sum = 0;
for (int j =1; j<=sz; j++){
sum += map.get(key);
}
hashNum += sum;
}
}
public void timeArray(int nTimes){
for (int i=0; i <nTimes; i++){
double sum = 0;
for (int j=0; j< array.length; j++) {
sum += array[j];
}
arrayNum += sum;
}
}
}
public static void main(String[] args){
Runner.main(PerfBenchmark.class, new String[0]);
System.out.println(hashNum);
System.out.println(arrayNum);
}
}
答案 1 :(得分：3)
我可以重现您的结果并解释它们。
<强>生殖
public abstract class Benchmark {
final String name;
public Benchmark(String name) {
this.name = name;
}
abstract int run(int iterations) throws Throwable;
private BigDecimal time() {
try {
int nextI = 1;
int i;
long duration;
do {
i = nextI;
long start = System.nanoTime();
run(i);
duration = System.nanoTime() - start;
nextI = (i << 1) | 1;
} while (duration < 100000000 && nextI > 0);
return new BigDecimal((duration) * 1000 / i).movePointLeft(3);
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
@Override
public String toString() {
return name + "\t" + time() + " ns";
}
public static void main(String[] args) throws Exception {
Benchmark[] benchmarks = {
new Benchmark("array lookup") {
Double[] array = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
@Override
int run(int iterations) throws Throwable {
double sum = 0;
for (int i = 0; i < iterations; i++) {
for (int j = 0; j < array.length; j++) {
sum += array[j];
}
}
return (int) sum;
}
}, new Benchmark("map lookup") {
Map<String, Double> map = new HashMap<>();
{
map.put("1", new Double(1));
map.put("2", new Double(2));
map.put("3", new Double(3));
map.put("4", new Double(4));
map.put("5", new Double(5));
map.put("6", new Double(6));
map.put("7", new Double(7));
map.put("8", new Double(8));
map.put("9", new Double(9));
map.put("10", new Double(10));
}
@Override int run(int iterations) throws Throwable {
String key = "1";
double sum = 0;
for (int i=0; i <iterations; i++){
for (int j =1; j<=map.size(); j++){
sum += map.get(key);
}
}
return (int) sum;
}
}
};
for (Benchmark bm : benchmarks) {
System.out.println(bm);
}
}
}
在我有点过时的笔记本上，当JDK 1.7是-server模式时，会打印：
array lookup 15.250 ns
map lookup 124.946 ns
为什么我会得到与durron597不同的结果？正如我在评论中指出的那样，他每次迭代都会打印到System.out。如果这实际上是I / O，那么它比地图查找要昂贵得多。您可以通过将基准更改为：
来查看测试结果 }, new Benchmark("array lookup with printing") {
Double[] array = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
@Override
int run(int iterations) throws Throwable {
for (int i = 0; i < iterations; i++) {
double sum = 0;
for (int j = 0; j < array.length; j++) {
sum += array[j];
}
System.out.println(sum);
}
return 0;
}
}, new Benchmark("map lookup with printing") {
Map<String, Double> map = new HashMap<>();
{
map.put("1", new Double(1));
map.put("2", new Double(2));
map.put("3", new Double(3));
map.put("4", new Double(4));
map.put("5", new Double(5));
map.put("6", new Double(6));
map.put("7", new Double(7));
map.put("8", new Double(8));
map.put("9", new Double(9));
map.put("10", new Double(10));
}
@Override int run(int iterations) throws Throwable {
String key = "1";
for (int i=0; i <iterations; i++){
double sum = 0;
for (int j =1; j<=map.size(); j++){
sum += map.get(key);
}
System.out.println(sum);
}
return 0;
}
}
打印以下时间（如果System.out是文件，则eclipse控制台的数字相似）
array lookup with printing 43301.251 ns
map lookup with printing 18330.935 ns
这比没有打印大约多100倍，所以我们主要在这里测量I / O.
<强>解释
数组查找仅涉及检查数组索引是否有效，将索引添加到基址以及从内存中读取单词。在您的情况下，您甚至循环遍历数组，这使Java Hotspot VM能够跳过边界检查。
HashMap查找执行以下代码：
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
static int indexFor(int h, int length) {
return h & (length-1);
}
// from String.class
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
...
}
即使考虑到一些分支很少被采用，地图查找包含的操作远远多于数组访问。这需要更长的时间并不奇怪。
当然，性能差异在实际代码中几乎不重要 - 而且比较是不公平的，因为Map比数组更灵活。
答案 2 :(得分：2)
是的，这里的费用是计算密钥。
如果您知道索引，则没有理由使用像HashMap这样的复杂数据结构而不是普通数组。
当您的密钥未知且基于对象的内容时，您可能希望使用HashMap。所以一个更有效的例子是从你想要找到的对象开始并搜索数组，而不是知道它在哪里，因为这就是HashMap的作用。
答案 3 :(得分：1)
如果您了解HashMap实际上是一个哈希表，它会将您的数据分散到整个底层数组中，并且必须计算索引，在数组中查找并将其交还回来，这并不奇怪。 。另一方面，数组是一个连续的内存块，在查找索引的位置时不涉及任何计算。
除此之外，你要以一种非常可预测的顺序访问数组这一事实，因此预取内存就像所有现代处理器一样，不会造成任何失误。
答案 4 :(得分：1)
get()需要对密钥进行哈希处理，并且还需要对密钥执行相等比较（因为可能有两个不同的密钥散列到支持数组中的相同索引） - 您的性能比较会有如果你使用超过10个键/数组元素，那就更加不平衡了，因为这会增加String#equals方法的平均成本（尽管你可以通过HashMap<Integer, Double>避免这种情况）
This is what HashMap#get is doing - for循环适用于表格存储多个密钥的情况，这些密钥在后备阵列中存储了相同的索引（在性能测试中可能没有发生这种情况，意味着循环只执行一次迭代）
for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}