当 Array 的索引已知时，使用 Arrays 或 HashMaps 是否更好(在性能方面)？请记住，示例中的“对象数组/映射”只是一个示例，在我的实际项目中它是由另一个类生成的，所以我不能使用单个变量。

数组示例:

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 示例:

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)

编辑: HashMap 似乎更快 数组:128ms 哈希:103ms

当使用更少的周期时，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();
}

}

最佳答案

HashMap 在下面使用一个数组，所以它永远不会比正确使用数组更快。

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

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

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

微基准测试的一个常见问题是 JIT，它非常擅长删除不执行任何操作的代码。如果你不小心，你只会测试你是否对 JIT 感到困惑，以至于它无法锻炼你的代码什么都做不了。

这是您可以编写优于 C++ 系统的微基准的原因之一。这是因为 Java 是一种更简单的语言，更容易推理并因此检测出无用的代码。这可能会导致测试表明 Java 比 C++ 更快地执行“无用”；)

关于java - Hashmap 与数组性能，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6462055/