Hashmap 与数组性能 [英] Hashmap vs Array performance

问题描述

当数组的索引已知时，使用数组或哈希映射(性能方面)更好吗?请记住，示例中的对象数组/映射"只是一个示例，在我的实际项目中它是由另一个类生成的，因此我无法使用单个变量.

Is it (performance-wise) better to use Arrays or HashMaps when the indexes of the Array are known? Keep in mind that the 'objects array/map' in the example is just an example, in my real project it is generated by another class so I cant use individual variables.

数组示例:

SomeObject[] objects = new SomeObject[2];
objects[0] = new SomeObject("Obj1");
objects[1] = new SomeObject("Obj2");

void doSomethingToObject(String Identifier){
    SomeObject object;
    if(Identifier.equals("Obj1")){
        object=objects[0];
    }else if(){
        object=objects[1];
    }
    //do stuff
}

HashMap 示例:

HashMapExample:

HashMap objects = HashMap();
objects.put("Obj1",new SomeObject());
objects.put("Obj2",new SomeObject());

void doSomethingToObject(String Identifier){
    SomeObject object = (SomeObject) objects.get(Identifier);
    //do stuff
}

HashMap 看起来好多了，但我真的需要在这方面的性能，以便优先考虑.

The HashMap one looks much much better but I really need performance on this so that has priority.

Array 就是这样，仍然欢迎提出建议

Well Array's it is then, suggestions are still welcome

我忘了说，Array/HashMap 的大小总是一样的 (6)

I forgot to mention, the size of the Array/HashMap is always the same (6)

HashMaps 似乎更快阵列:128ms哈希:103ms

It appears that HashMaps are faster Array: 128ms Hash: 103ms

当使用更少的周期时，HashMaps 的速度甚至是原来的两倍

When using less cycles the HashMaps was even twice as fast

测试代码:

import java.util.HashMap;
import java.util.Random;

public class Optimizationsest {
private static Random r = new Random();

private static HashMap<String,SomeObject> hm = new HashMap<String,SomeObject>();
private static SomeObject[] o = new SomeObject[6];

private static String[] Indentifiers = {"Obj1","Obj2","Obj3","Obj4","Obj5","Obj6"};

private static int t = 1000000;

public static void main(String[] args){
    CreateHash();
    CreateArray();
    long loopTime = ProcessArray();
    long hashTime = ProcessHash();
    System.out.println("Array: " + loopTime + "ms");
    System.out.println("Hash: " + hashTime + "ms");
}

public static void CreateHash(){
    for(int i=0; i <= 5; i++){
        hm.put("Obj"+(i+1), new SomeObject());
    }
}

public static void CreateArray(){
    for(int i=0; i <= 5; i++){
        o[i]=new SomeObject();
    }
}

public static long ProcessArray(){
    StopWatch sw = new StopWatch();
    sw.start();
    for(int i = 1;i<=t;i++){
        checkArray(Indentifiers[r.nextInt(6)]);
    }
    sw.stop();
    return sw.getElapsedTime();
}



private static void checkArray(String Identifier) {
    SomeObject object;
    if(Identifier.equals("Obj1")){
        object=o[0];
    }else if(Identifier.equals("Obj2")){
        object=o[1];
    }else if(Identifier.equals("Obj3")){
        object=o[2];
    }else if(Identifier.equals("Obj4")){
        object=o[3];
    }else if(Identifier.equals("Obj5")){
        object=o[4];
    }else if(Identifier.equals("Obj6")){
        object=o[5];
    }else{
        object = new SomeObject();
    }
    object.kill();
}

public static long ProcessHash(){
    StopWatch sw = new StopWatch();
    sw.start();
    for(int i = 1;i<=t;i++){
        checkHash(Indentifiers[r.nextInt(6)]);
    }
    sw.stop();
    return sw.getElapsedTime();
}

private static void checkHash(String Identifier) {
    SomeObject object = (SomeObject) hm.get(Identifier);
    object.kill();
}

}

推荐答案

HashMap 在底层使用数组，因此它永远不会比正确使用数组更快.

HashMap uses an array underneath so it can never be faster than using an array correctly.

Random.nextInt() 比您正在测试的要慢很多倍，即使使用数组来测试数组也会使您的结果产生偏差.

Random.nextInt() is many times slower than what you are testing, even using array to test an array is going to bias your results.

您的数组基准测试如此缓慢的原因是由于相等比较，而不是数组访问本身.

The reason your array benchmark is so slow is due to the equals comparisons, not the array access itself.

HashTable 通常比 HashMap 慢得多，因为它做了很多相同的事情，但也是同步的.

HashTable is usually much slower than HashMap because it does much the same thing but is also synchronized.

微基准测试的一个常见问题是 JIT，它非常擅长删除不做任何事情的代码.如果您不小心，您将只会测试您是否已经将 JIT 弄糊涂了，以至于它无法运行您的代码并没有做任何事情.

A common problem with micro-benchmarks is the JIT which is very good at removing code which doesn't do anything. If you are not careful you will only be testing whether you have confused the JIT enough that it cannot workout your code doesn't do anything.

这是您可以编写超越 C++ 系统的微基准测试的原因之一.这是因为 Java 是一种更简单的语言，更容易推理并因此检测没有任何用处的代码.这可能导致测试表明 Java没有任何用处"比 C++ 快得多；)

This is one of the reason you can write micro-benchmarks which out perform C++ systems. This is because Java is a simpler language and easier to reason about and thus detect code which does nothing useful. This can lead to tests which show that Java does "nothing useful" much faster than C++ ;)

这篇关于Hashmap 与数组性能的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！