Hashmap与阵列性能

Question

当已知Array的索引时,使用Arrays或HashMaps是否(性能方面)更好？请记住,示例中的'objects array/map'只是一个示例,在我的实际项目中它由另一个类生成,因此我无法使用单个变量.

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更快的阵列:128毫秒哈希:103毫秒

当使用较少的周期时,HashMaps的速度甚至快了两倍

测试代码:

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() 比你测试的要慢很多倍,即使使用数组来测试数组也会使你的结果产生偏差.

你的数组基准测试速度如此之慢的原因是由于等于比较,而不是数组访问本身.

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

微基准测试的一个常见问题是JIT非常擅长删除无法执行任何操作的代码.如果你不小心,你只会测试你是否已经混淆了JIT,它无法锻炼你的代码什么都不做.

这是您可以编写执行C++系统的微基准测试的原因之一.这是因为Java是一种更简单的语言,更易于推理,从而检测出无用的代码.这可以导致测试表明Java"没有用"比C++快得多;)

Answer 2

当索引已知时，数组速度更快（HashMap 在幕后使用链表数组，这在数组访问之上增加了一些开销，更不用说需要完成的哈希操作了）

仅供参考，HashMap<String,SomeObject> objects = HashMap<String,SomeObject>();这样你就不必演员了