Question

我读到了TreeSet如何比HashSet慢，（将元素添加到TreeSet中的速度较慢）所以我进行了性能测试，我试图找出是否更好地将元素添加到HashSet然后将它们移入树集或首先将它们放在那里。看起来插入HashSet的元素更快，但只有当我插入大量元素时，为什么？我已经读过，如果我不需要排序的元素，总是使用HashSet，但显然，有时候它会变慢。

当我插入具体值（“1”）而不是随机数时，TreeSet也更快，因为没有排序，所以我怎么知道何时使用HashSet或TreeSet？

我的第二个问题，当我像这样创建TreeSet时，为什么我不能访问“NavigableSet”方法？

Set<Integer> treeSet = new TreeSet<Integer>();     //cant type treeSet.lower(e: E)
TreeSet<Integer> treeSet = new TreeSet<Integer>(); //can  type treeSet.lower(e: E)

感谢您帮助我。

结果如下：

5 000 000（随机数）

enter image description here

5 000 000（数字“1”）

enter image description here

500 000（随机数）

enter image description here

50 000（随机数）

enter image description here

这是我的代码：

package performancetest;

import java.text.DecimalFormat;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.TreeSet;

public class HashSet_vs_TreeSet {
private static DecimalFormat df = new DecimalFormat("#.#####");
private static double hashTime, treeTime, hashToTreeTime;
private static int numbers = 0;

public static void main(String[] args){
    start();
    hashSetTest();
    treeSetTest();
    fromHashToTreeSet();
    difference();
}

/**
 * in this method, instead of "System.exit(1)" i try'ed "start()" but when i did lets say three mistakes, after correct input the 
 * methods hashSetTest();treeSetTest();fromHashToTreeSet();difference(); were running 4 times... i made this method exactly for the
 * purpose to repeat itself in case of a input mistake.
 */
public static void start(){
    System.out.print("Enter a number(a advise bigger or equal to 50 000): ");
    Scanner scan = new Scanner(System.in);
    try{
        numbers = scan.nextInt();
    }catch(InputMismatchException e){
        System.out.println("ERROR: You need to enter a number");
        System.exit(1);
    }
    System.out.println(numbers + " numbers in range from 0-99 was randomly generated into " +
            "\n1)HashSet\n2)TreeSet\n3)HashSet and then moved to TreeSet\n");
}

public static void hashSetTest(){
    /**
     * i try'ed HashSet<Integer> hashSet = new HashSet<Integer>();
     * but changing the load factor didn't make any difference, what its good for then ?
     */
    HashSet<Integer> hashSet = new HashSet<Integer>(5000,(float) 0.5);
    double start = System.currentTimeMillis() * 0.001;

    for (int i = 0; i < numbers; i++) {
        hashSet.add((int)(Math.random() * 100));
    }

    hashTime = (System.currentTimeMillis() * 0.001) - start;

    System.out.println("HashSet takes " + df.format(hashTime) + "s");
}

public static void treeSetTest(){
    TreeSet<Integer> treeSet = new TreeSet<Integer>();
    double start = System.currentTimeMillis() * 0.001;

    for (int i = 0; i < numbers; i++) {
        treeSet.add((int)(Math.random() * 100));
    }

    treeTime = (System.currentTimeMillis() * 0.001) - start;

    System.out.println("TreeSet takes " + df.format(treeTime) + "s");
}

public static void fromHashToTreeSet(){
    HashSet<Integer> hashSet = new HashSet<Integer>();
    double start = System.currentTimeMillis() * 0.001;

    for (int i = 0; i < numbers; i++) {
        hashSet.add((int)(Math.random() * 100));
    }

    TreeSet<Integer> treeSet = new TreeSet<Integer>(hashSet);
    hashToTreeTime = (System.currentTimeMillis() * 0.001) - start;

    System.out.println("TreeSet from HashSet takes " + df.format(hashToTreeTime) + "s");
}

public static void difference(){
    double differenceSec = 0;
    double differenceTimes = 0;

    if(hashTime < treeTime){
        differenceSec = (treeTime - hashTime);
        differenceTimes = (treeTime / hashTime);
        System.out.println("\nHashSet takes " + df.format(differenceSec) + "s less then TreeSet, it is " + df.format(differenceTimes) + " times faster");
    }else{
        differenceSec = (hashTime - treeTime);
        differenceTimes = (hashTime / treeTime);
        System.out.println("\nTreeSet takes " + df.format(differenceSec) + "s less then HashSet, it is " + df.format(differenceTimes) + " times faster");
    }
}
}

Answer 1

那么，当你谈到TreeSet和HashSet的性能时，你应该清楚地理解这些结构是如何组织起来的。它的组织结果。

通常，TreeSet是一种结构，其中所有元素都在a binary tree中组织。因此，添加成员或访问成员是〜O(log(N))。

另一方面，HashSet是一个类似于数组的结构。不同之处在于，数组索引是唯一的数字，而在HashSet中，每个键都需要在a hash function的帮助下转换为索引。哈希函数可以为不同的输入数据产生相同的结果，这种情况称为hash collision。一个好的哈希函数（是的，它们可能是坏的和好的）在给定的一组输入数据上产生尽可能多的唯一结果。

因此，访问哈希集中的数据需要计算哈希函数的计算（在Java中通常是.hashCode()）并且可能解决冲突。这是估计为O（1），即恒定的操作次数。

你应该明白O（1）并不总是小于O（log（n）），它渐近并且足够大n。另外正确选择哈希函数也很重要。

Answer 2

0）JVM基准测试非常复杂。几乎总是你不是在测量你认为自己在测量的东西。来自Oracle的人员进行微基准测试的http://openjdk.java.net/projects/code-tools/jmh/。您可以尝试一些基准测试框架和指南。

JIT编译器预热，初始内存分配，垃圾收集器以及许多其他事情可能会使您的基准无效。

1）关于第一个问题，请参阅Hashset vs Treeset

2）Set<Integer> treeSet = new TreeSet<Integer>(); //cant type treeSet.lower(e: E)

它是如何运作的。您将treeSet声明为Set。 Set不会扩展NavigableSet。如果你愿意，你可以明确地施放。但是如果你想访问NavigableSet方法，为什么你不能将treeSet声明为NavigableSet

Set<Integer> treeSet = new TreeSet<Integer>(); 
Integer lower = ((NavigableSet) treeSet).lower(); // thus should work

Answer 3

尝试运行此代码。我从codeforces.ru拿走了它。这是HashSet / HashMap如何工作的演示。添加10 ^ 5值需要1.3到1.4秒。根据相关主题 - 洗牌赢得了帮助（我没有尝试过）。 TreeSet永远不会表现出如此糟糕的表现。

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Main implements Runnable {

    public static void main(String[] args) {
        new Thread(null, new Main(), "", 16 * (1L << 20)).start();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            solve();
            long t2 = System.currentTimeMillis();
            System.out.println("Time = " + (t2 - t1));
        } catch (Throwable t) {
            t.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    // solution

    int hashinv(int h) {
        h ^= (h >>> 4) ^ (h >>> 7) ^ (h >>> 8) ^ (h >>> 14) ^ (h >>> 15)
                ^ (h >>> 18) ^ (h >>> 19) ^ (h >>> 20) ^ (h >>> 21)
                ^ (h >>> 23) ^ (h >>> 26) ^ (h >>> 28);
        return h;
    }

    int bitreverse(int h) {
        int res = 0;
        for (int i = 0; i < 31; i++)
            if ((h & (1 << i)) != 0)
                res |= (1 << (30 - i));
        return res;
    }

    void solve() throws IOException {
        final int size = 100000;
        int[] s = new int[size];
        for (int i = 0, val = 0; i < size; i++) {
            s[i] = Integer.MAX_VALUE;
            while (s[i] > 1000000000)
                s[i] = hashinv(bitreverse(val++));
        }
        long startTime = System.currentTimeMillis();
        HashSet<Integer> h = new HashSet<Integer>(size);
        for (int i = 0; i < size; i++)
                h.add(s[i]);
        System.out.println("HashSet adding time = " + (System.currentTimeMillis() - startTime));
    }

}

HashSet和TreeSet性能测试

3 个答案: