HashMaps与阵列性能

Question

在知道数组索引的情况下，使用Arrays或HashMaps更好（在性能方面）吗？请记住，示例中的“对象数组/映射”只是一个示例，在我的真实项目中，它是由另一个类生成的，因此我不能使用单个变量。

ArrayExample：

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
}

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看起来好得多，但我确实需要在此方面具有性能，因此具有优先权。

编辑： 那么是数组，仍然欢迎建议

编辑： 我忘了提，Array / HashMap的大小始终相同（6）

编辑： 似乎HashMaps更快数组：128ms哈希：103ms

使用较少的周期时，HashMap的速度甚至快两倍

测试代码：

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

}

Answer 1

HashMap使用下面的数组，因此它永远不会比正确使用数组快。

Random.nextInt() 比测试的速度慢很多倍，即使使用数组测试数组也会使结果产生偏差。

数组基准测试之所以如此缓慢的原因是由于equals比较，而不是数组访问本身。

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

微基准测试的一个常见问题是JIT，它非常擅长删除不执行任何操作的代码。如果您不小心，则将仅测试您是否对JIT感到困惑，以至于JIT无法执行您的代码不会执行任何操作。

这是您可以编写性能优于C
系统的微基准的原因之一。这是因为Java是一种更简单的语言，更易于推理，因此可以检测无用的代码。这可能会导致测试表明Java的“没什么用”比C

快得多；）