【Simple Java】怎样高效判断数组中是否包含某个特定值

怎样判断一个无序数组是否包含某个特定值?这在JAVA中是一个非常实用的操作,在Stack Overflow问答网站中也同样是一个热门问题;

要完成这个判断,可以通过若干种不同的方式实现,每种实现方式对应的时间复杂读会有很大的不同;

接下来我将展示不同实现方式的时间开销。

四种不同方式检查数组是否包含某个值

使用List:

    public static boolean useList(String[] arr, String targetValue) {
        return Arrays.asList(arr).contains(targetValue);
    }

使用Set:

    public static boolean useSet(String[] arr, String targetValue) {
        Set<String> set = new HashSet<String>(Arrays.asList(arr));
        return set.contains(targetValue);
    }

使用简单的循环语句:

    public static boolean useLoop(String[] arr, String targetValue) {
        for (String s : arr) {
            if (s.equals(targetValue))
                return true;
        }
        return false;
    }

使用Arrays.binarySearch()方法:

下面的代码是错误的,之所以列在下面是出于完整性考虑(四种判断方式),binarySearch()二分查找只能用于有序数组。

运行下面程序,你有可能会得到异常结果;

    public static boolean useArraysBinarySearch(String[] arr, String targetValue) {
        int a = Arrays.binarySearch(arr, targetValue);
        if (a > 0)
            return true;
        else
            return false;
    }

四种实现方式对应的时间开销

以下代码可计算出以上四种实现方式大致的时间消耗,基本策略是使用不同大小的数组(5,1k,10k)做测试,可能不是很精准,但这种方式很简单;

数组大小为5:

public static void main(String[] args) {
        String[] arr = new String[] { "CD", "BC", "EF", "DE", "AB" };
        // use list
        long startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useList(arr, "A");
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println("useList: " + duration / 1000000);
        // use set
        startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useSet(arr, "A");
        }
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("useSet: " + duration / 1000000);
        // use loop
        startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useLoop(arr, "A");
        }
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("useLoop: " + duration / 1000000);
        // use Arrays.binarySearch()
        startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useArraysBinarySearch(arr, "A");
        }
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("useArrayBinary: " + duration / 1000000);
    }

运行结果:

useList: 13
useSet: 72
useLoop: 5
useArraysBinarySearch: 9

数组大小为1000:

        String[] arr = new String[1000];
        Random s = new Random();
        for (int i = 0; i < 1000; i++) {
            arr[i] = String.valueOf(s.nextInt());
        }

运行结果:

useList: 112
useSet: 2055
useLoop: 99
useArrayBinary: 12

数组大小为10000:

        String[] arr = new String[10000];
        Random s = new Random();
        for (int i = 0; i < 10000; i++) {
            arr[i] = String.valueOf(s.nextInt());
        }

运行结果:

useList: 1590
useSet: 23819
useLoop: 1526
useArrayBinary: 12

结论

从测试结果可以看出,使用简单的循环语句比使用任何集合都高效,很大一部分开发人员选择使用第一种方法(List),但这种方法其实是相对低效的。在使用集合提供的API前,需要把一个数组放到集合里,这需要消耗一定的时间,特别是对于Set集合;(注:其实ArrayList集合的性能跟普通的循环语句差不多,因为对于ArrayList,转换成集合的时候,仅仅是改变了内部的数组索引,遍历判断的时候,跟普通的循环语句类似);

如果要使用Arrays.binarySearch()方法,前提是数组要有序,在这个测试demo中,很显然数组是无序的,因此不该被使用;

事实上,如果你确实需要高效的去检查数组或集合中是否包含某个值,一个有序列表或者有序树能把时间复杂度降低到O(log(n)),或者使用散列集合,时间复杂度为O(1);

译文链接:http://www.programcreek.com/2014/04/check-if-array-contains-a-value-java/

时间: 2024-11-06 18:56:22

【Simple Java】怎样高效判断数组中是否包含某个特定值的相关文章

如何高效地判断数组中是否包含某特定值

 如何检查一个未排序的数组中是否包含某个特定值,这是一个在Java中非常实用并且频繁使用的操作.另外,这也是Stack Overflow上面非常受关注的问题.在得票数最多的答案中,可以看到,检查数组中是否包含特定值可以用多种不同的方式实现,但是时间复杂度差别很大.下面,我将为大家展示各种方法及其需要花费的时间. 1.检查数组中是否包含特定值的四种不同方法 1)使用List: 1 2 3 public static boolean useList(String[] arr, String ta

在Java中如何高效判断数组中是否包含某个元素

如何检查一个数组(无序)是否包含一个特定的值?这是一个在Java中经常用到的并且非常有用的操作.同时,这个问题在Stack Overflow中也是一个非常热门的问题.在投票比较高的几个答案中给出了几种不同的方法,但是他们的时间复杂度也是各不相同的.本文将分析几种常见用法及其时间成本. 检查数组是否包含某个值的方法 使用List public static boolean useList(String[] arr, String targetValue) { return Arrays.asLis

java中如何高效判断数组中是否包含某个特定的值

四种不同方式检查数组是否包含某个值 使用List: public static boolean useList(String[] arr, String targetValue) { return Arrays.asList(arr).contains(targetValue); } 使用Set: public static boolean useSet(String[] arr, String targetValue) { Set<String> set = new HashSet<S

node js 判断数组中是否包含某个值

判断数组中是否包含某个值这里有四种方法.用的测试数据: let arr=["a","b","c"]; let arr2={"a":"aaa","b":"bbb","c":"ccc"}; in判断是否在数组的key里in操作符针对的是key,而非value.而对于普通的一维数组来说,key是隐藏的.所以,对于判断某个数组中是否含有

js中判断数组中是否包含某元素的方法

方法一:array.indexOf(item,start):元素在数组中的位置,如果没与搜索到则返回 -1. 参数 描述 item 必须.查找的元素. start 可选的整数参数.规定在数组中开始检索的位置.它的合法取值是 0 到 stringObject.length - 1. 如省略该参数,则将从字符串的首字符开始检索. 实际用法:if(arr.indexOf(某元素) > -1){//则包含该元素} var fruits = ["Banana", "Orange&

JQuery判断数组中是否包含某个元素$.inArray(&quot;js&quot;, arr);

var arr = [ "xml", "html", "css", "js" ]; $.inArray("js", arr);  //返回 3, 如果不包含在数组中,则返回 -1;

JQuery判断数组中是否包含某个元素$.inArray(&quot;元素字符串&quot;, 数组名称);

var arry = [ "C#", "html", "css", "JavaScript" ]; var result= $.inArray("C#", arry); //如果arry数组里面存在"C#" 这个字符串则返回该字符串的数组下标,否则返回(不包含在数组中) -1

哈希(6) - 判断数组中是否存在重复元素且距离在K之内

给定一个包含多个重复元素的未排序的数组.另外给定一个数字k,且k小于数组大小.判断数组中是否包含重复元素,且它们相隔的距离处于范围k之内. 例如: Input: k = 3, arr[] = {1, 2, 3, 4, 1, 2, 3, 4} Output: false 所有重复元素的距离>k. Input: k = 3, arr[] = {1, 2, 3, 1, 4, 5} Output: true 存在重复元素1,且距离为3(==k). Input: k = 3, arr[] = {1, 2,

在Java中判断数组中包含某个元素的几种方式的比较

闲来无事,将java中判断数组中包含某个元素的几种方式的速度进行对比,直接上代码 talk is cheap, show you the code package test.contain.lishaojie; import java.util.Arrays;import java.util.HashSet;import java.util.Set; public class TestContain { /** * @param args */ public static void main(S