我愿驳斥我在答复中看到的两条神话:

Java的汇编是,是的,是按字母顺序排列的,但最终是在大多数运行环境中按本地编码编制。 说C的人必然要更快地掌握整个故事,我可以说,由于JIT编纂者能够使机器规格最佳化,因此,通过编造的语文必然要更快。

可能产生差异的一些事情是:

• Python s hash tables and sets are the most heavily optimized objects in Python, and Python s hash function is designed to return similar results for similar inputs: hashing an integer just returns the integer, guaranteeing that you will NEVER see a collision in a hash table of consecutive integers in Python.
• A secondary effect of the above is that the Python code will have high locality of reference as you ll be accessing the hash table in sequence.
• Java does some fancy boxing and unboxing of integers when you add them to collections. On the bonus side, this makes arithmetic way faster in Java than Python (as long as you stay away from bignums) but on the downside it means more allocations than you re used to.

www.un.org/Depts/DGACM/index_spanish.htm Edit:根据分配模式,树苗对实际使用来说可能更快。 我的下列评论仅涉及这一简化方案。 然而,我认为这不会带来巨大变化。 真正的问题存在于其他地方。

这里有几个人建议用TreeSet替换HashSet。对我来说，这听起来非常奇怪，因为没有一种数据结构的插入时间是O(log n)比预先分配足够的存储所有元素的桶的O(1)结构更快。

这里有一些基准:

import java.util.*;
class SpeedTest
{    
    public static void main(String[] args)
    {        
        long startTime;
        long totalTime;
        int iterations = 10000000;
        Set counts;

        System.out.println("HashSet:");
        counts = new HashSet((2*iterations), 0.75f);
        startTime = System.currentTimeMillis();
        for(int i=0; i<iterations; i++) {
            counts.add(i);
        }
        totalTime = System.currentTimeMillis() - startTime;
        System.out.println("TOTAL TIME = "+( totalTime/1000f) );
        System.out.println(counts.size());

        counts.clear();

        System.out.println("TreeSet:");
        counts = new TreeSet();
        startTime = System.currentTimeMillis();
        for(int i=0; i<iterations; i++) {
            counts.add(i);
        }
        totalTime = System.currentTimeMillis() - startTime;
        System.out.println("TOTAL TIME = "+( totalTime/1000f) );
        System.out.println(counts.size());
    }
}

我的机器是:

$ java -Xmx1024M SpeedTest
HashSet:
TOTAL TIME = 4.436
10000000
TreeSet:
TOTAL TIME = 8.163
10000000

一些人还争辩说,箱子 is不是一种绩效问题,而设定标语是费用不高的。 固然物体的制造速度快,但肯定不会像原始材料一样快:

import java.util.*;
class SpeedTest2
{    
    public static void main(String[] args)
    {        
        long startTime;
        long totalTime;
        int iterations = 10000000;

        System.out.println("primitives:");
        startTime = System.currentTimeMillis();
        int[] primitive = new int[iterations];
        for (int i = 0; i < iterations; i++) {
            primitive[i] = i;
        }
        totalTime = System.currentTimeMillis() - startTime;
        System.out.println("TOTAL TIME = "+( totalTime/1000f) );

        System.out.println("primitives:");
        startTime = System.currentTimeMillis();
        Integer[] boxed = new Integer[iterations];
        for (int i = 0; i < iterations; i++) {
            boxed[i] = i;
        }
        totalTime = System.currentTimeMillis() - startTime;
        System.out.println("TOTAL TIME = "+( totalTime/1000f) );
    }
}

结果:

$ java -Xmx1024M SpeedTest2
primitives:
TOTAL TIME = 0.058
primitives:
TOTAL TIME = 1.402

此外,由于制造大量物品,垃圾收集器增加了间接费用。 当你开始忘掉数以千万计的活物体时,这一点就变得很重要。

我认为,这样的基准毫无意义。 我没有解决像试验案例这样的问题。 它并不令人可怕。

我非常希望看到利用NumPy和JAMA找到有意义的线性黄色解决办法。 Maybe 我试图这样做,并报告结果。

I m 不太熟悉python,但我确实知道HashSet 可能含有原始缩略语,如你说counts.add(i)。 正在把自动箱装成<代码>新 Integer(i)。 这很可能是你的问题。

如果出于某种原因,你确实需要一套0到某些大纳米之间的分类,那么,它很可能被宣布为一种 b子,即新的 b子。 然后,你可以穿透所装的阵列和标记项目,而不必承担制造 n子的费用。 如果你想继续使用第8号大体,并直接使用个别轨道。 或许是BigInteger。

EDIT

请停止为我的回答投赞成票。它是错误的。

EDIT

毫无疑问,它是错误的。 如果我回答问题,把这套住房与N Integers混为一谈,我就会获得类似的业绩。 如果我把休息内容改为:

    Integer[] ints = new Integer[N];
    for (int i = 0; i < N; ++i) {
        ints[i] = i;
    }

之后只有2秒。 如果你根本不储存Integer,它就花费不到200米。 拨款1 000 000 000美元 愤怒物体确实需要一定时间,但看起来像大多数时间一样在哈希特行动区内使用。

在此,我要集中谈谈若干问题。

首先,如果它只是执行一次方案,它是否需要另外几秒?

第二,这只是一个缩影。 微观基准对于比较业绩是毫无意义的。

启动有几个问题。

贾瓦的运行时间比沙里花得更长,需要从磁盘上装载,并且需要更多的记忆,如果你正在打捞,这种记忆可能很重要。

如果您有打下<代码>-Xms>,那么你只能管理GC,以便转播。 从一开始,肥料也出现适当规模。

确实, Java开始解释,然后汇编。 大约1 500个供太阳客户使用的频率[C1]热点和10 000个服务器[C2]。 服务器热点将最终给你更好的业绩,但会获得更多的记忆。 我们可能看到用户热电站使用服务器,以达到两个世界的最佳标准。 然而,这通常不应是一个二者的问题。

www.un.org/Depts/DGACM/index_spanish.htm 最重要的是,你可能会制造两个物体。 就大多数法典而言,你不会为这种执行的比例制造这些微小物体。 树木 点数可能更好,点数为6u14,和谐甚至更好。

也许可以通过在参考文献中储存小的喷雾器胜出,而不是实际上有物体。 这无疑是一种良好的选择。

存在许多基准的问题,就是你正在用一种方法混合许多不同的法典。 请不要写一下你所关心的那种法典吗? 因此,你为什么试图进行业绩测试,而这种测试与你实际上希望迅速运行的守则不同?

改进数据结构: 诸如<条码>BitSet等一些内容似乎具有意义(尽管如此,这可能会或不会影响业绩)。

你们需要多驾车,以获得“how快”的真正想法。 联合核查机制启动时间[一个]是 Java版单一运行时间。

你还重新创建了一个具有大量初步能力的哈希斯特,这意味着将利用许多现有位置来创建支持哈希姆博,与你创建一套基本文件时的沙尔格不同。 很难说这是否会阻碍,因为正如你的哈希特种植一样,它必须重新定位所储存的物体。

你们是否使用悬挂守卫国旗? 否则,你就可以检验业绩。 (在进行试验之前,你还必须热情地放弃。)

另外,你可能希望使用<代码>TreeSet<Integer>。 Hash 从长远来看,一套办法将比较缓慢。

你们是谁? 我希望这是最新的。

http://www.ohchr.org。

当我说使用TreeSet时，我是指一般情况，而不是针对这个基准测试。TreeSet可以处理对象非均匀散列的现实问题。如果在HashSet中有太多对象在同一个容器中，你的性能将大约为O(n)。