java数组查找算法实现比较

java数组查找算法实现比较

本文我们看看java不同数组查找算法,并使用JMH(Java Microbenchmark Harness)比较它们的性能,确定最优算法。

数据准备

我们在数组中随机生成字符串用作示例数据:

String[] seedArray(int length) {
    String[] strings = new String[length];
    Random value = new Random();
    for (int i = 0; i < length; i++) {
        strings[i] = String.valueOf(value.nextInt());
    }
    return strings;
}

为在每个基准测试中使用相同的数组,我们声明一个内部类带有数量及数组,用于JMH测试:

@State(Scope.Benchmark)
public static class SearchData {
    static int count = 1000;
    static String[] strings = seedArray(1000);
}

要使用HMH测试,需引用依赖(gradle脚本):

compile group: 'org.openjdk.jmh', name: 'jmh-core', version: '1.20'
compile group: 'org.openjdk.jmh', name: 'jmh-generator-annprocess', version: '1.20'

基本搜索

三种常用的搜索方法为:数组所谓List查找,数组作为Set查找,循环数组检查每个元素。让我们看看这三种方法:

boolean searchList(String[] strings, String searchString) {
    return Arrays.asList(SearchData.strings)
      .contains(searchString);
}

boolean searchSet(String[] strings, String searchString) {
    Set<String> stringSet = new HashSet<>(Arrays.asList(SearchData.strings));

    return stringSet.contains(searchString);
}

boolean searchLoop(String[] strings, String searchString) {
    for (String string : SearchData.strings) {
        if (string.equals(searchString))
        return true;
    }

    return false;
}

接下来我们使用三个类注解告诉JMH输出平均时间,单位为毫秒,进行5个预热迭代确保测试的可靠性:

@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 5)
@OutputTimeUnit(TimeUnit.MICROSECONDS)

然后在循环中运行每个测试:

@Benchmark
public void searchArrayLoop() {
    for (int i = 0; i < SearchData.count; i++) {
        searchLoop(SearchData.strings, "T");
    }
}

@Benchmark
public void searchArrayAllocNewList() {
    for (int i = 0; i < SearchData.count; i++) {
        searchList(SearchData.strings, "T");
    }
}

@Benchmark
public void searchArrayAllocNewSet() {
    for (int i = 0; i < SearchData.count; i++) {
        searchSet(SearchData.strings, "S");
    }
}

每个测试方法运行1000次,结果大概如下:

SearchArrayTest.searchArrayAllocNewList  avgt   20    937.851 ±  14.226  us/op
SearchArrayTest.searchArrayAllocNewSet   avgt   20  14309.122 ± 193.844  us/op
SearchArrayTest.searchArrayLoop          avgt   20    758.060 ±   9.433  us/op

循环方法最有效,但至少部分原因是取决与我们如何使用集合。每次调用searchList()方法创建新的List实例,每次调用searchSet()方法同时会创建新的List和新的HashSet,创建这些对象会有额外的开销,而数组循环没有。

有效搜索

如果我们只创建依次List和Set的实例,然后重用他们,结果如何呢,让我们试试:

public void searchArrayReuseList() {
    List asList = Arrays.asList(SearchData.strings);
    for (int i = 0; i < SearchData.count; i++) {
        asList.contains("T");
    }
}

public void searchArrayReuseSet() {
    Set asSet = new HashSet<>(Arrays.asList(SearchData.strings));
    for (int i = 0; i < SearchData.count; i++) {
        asSet.contains("T");
    }
}

使用同样的JMH注解运行这些方法,并同样包裹在循环中执行并比较,结果有很大的差异:

SearchArrayTest.searchArrayLoop          avgt   20    758.060 ±   9.433  us/op
SearchArrayTest.searchArrayReuseList     avgt   20    837.265 ±  11.283  us/op
SearchArrayTest.searchArrayReuseSet      avgt   20     14.030 ±   0.197  us/op

List比原先稍微快点,Set下降到不足原来的1%!
现在我们删除了每次搜索需要创建新集合的耗时操作,结果有一定意义。搜索hash表,基于Hashset类,时间复杂度为O(1),而数组,基于ArrayList是O(n).

二分查找

这里介绍另一种搜索方法:二分查找。虽然非常高效,但要求数组必须有序。
让我们排序并尝试二分查找:

@Benchmark
public void searchArrayBinarySearch() {
    Arrays.sort(SearchData.strings);
    for (int i = 0; i < SearchData.count; i++) {
        Arrays.binarySearch(SearchData.strings, "T");
    }
}
SearchArrayTest.searchArrayBinarySearch  avgt   20     26.527 ±   0.376  us/op

二分查找非常快,比HashSet稍微差点,最差情况性能为O(logn),介于数组与hash表之间。

总结

我们介绍了集中方式实现搜索数组。基于测试结果,HashSet性能最佳,但必须先创建并存储其中。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/neweastsun/article/details/79979264
个人分类: java java8
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭