服务器之家

服务器之家 > 正文

详解Java中数组判断元素存在几种方式比较

时间:2021-05-14 11:10     来源/作者:lonecloud

1. 通过将数组转换成list,然后使用list中的contains进行判断其是否存在

?
1
2
3
public static boolean uselist(string[] arr,string containvalue){
    return arrays.aslist(arr).contains(containvalue);
  }

 需要注意的是arrays.aslist这个方法中转换的list并不是java.util.arraylist而是java.util.arrays.arraylist,其中java.util.arrays.arraylist中不能对数组的长度进行扩容操作,这个尤为重要,其中contains实现如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@override
public boolean contains(object o) {
  //调用indexof方法判断其在那个位置,判断其时候为-1
   return indexof(o) != -1;
}
@override
public int indexof(object o) {
  //获取元素
  e[] a = this.a;
  //判断空
  if (o == null) {
    //循环判断
    for (int i = 0; i < a.length; i++)
      //如果元素为null
      if (a[i] == null)
       //则返回
       return i;
  } else {
    //如果其不为空
    for (int i = 0; i < a.length; i++)
     //判断元素与a[i]是否相等
      if (o.equals(a[i]))
       //相等返回i
       return i;
  }
      //否则返回-1
      return -1;
}

2. 使用set进行实现判断是否存在

?
1
2
3
public static boolean useset(string[] arr,string containvalue){
    return new hashset<>(arrays.aslist(arr)).contains(containvalue);
  }

  原理将数组->list->set使用set进行比较

源码:通过调用map的containskey实现的,而hashmap中则是通过遍历hash表中的key实现

?
1
2
3
ypublic boolean contains(object o) {
    return map.containskey(o);
  }

3. 使用循环来实现,自己编写一个循环来判断

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static boolean useloop(string[] arr,string containvalue){
    //判断是否为空
    if (arr==null||arr.length==0){
      return false;
    }
    for (int i = 0; i < arr.length; i++) {
      //all null
      if (containvalue!=null&&containvalue.equals(arr[i])){
        return true;
      }else if (arr[i]==null){
        return true;
      }
    }
    return false;
  }

4. 使用org.apache.commons.lang3.arrayutils中的contains方法来实现

?
1
2
3
public static boolean useutils(string[] arr,string containvalue){
    return arrayutils.contains(arr,containvalue);
  }

具体实现源码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static boolean contains(final object[] array, final object objecttofind) {
    //调用indexof进行判断位置
    return indexof(array, objecttofind) != index_not_found;
  }
  public static int indexof(final object[] array, final object objecttofind, int startindex) {
    //判断null
    if (array == null) {
      return index_not_found;
    }
    //判断起始位置
    if (startindex < 0) {
      startindex = 0;
    }
    //判断查询元素是否为null
    if (objecttofind == null) {
      //null则直接使用==进行循环判断位置
      for (int i = startindex; i < array.length; i++) {
        if (array[i] == null) {
          return i;
        }
      }
     //判断元素是不是array中的元素的实例,如果是则循环并采用equals进行判断
    } else if (array.getclass().getcomponenttype().isinstance(objecttofind)) {
      for (int i = startindex; i < array.length; i++) {
        if (objecttofind.equals(array[i])) {
          return i;
        }
      }
    }
    //返回没有找到
    return index_not_found;
  }

  使用循环1w次来检测效率

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static void recompilearr(string[] arr,string containvalue){
  //using list
  long start = system.nanotime();
  for (int i = 0; i < 10000; i++) {
    uselist(arr,containvalue);
  }
  long end=system.nanotime();
  system.out.println("using list->"+(end-start)/10000);
  //using set
  start = system.nanotime();
  for (int i = 0; i < 10000; i++) {
    useset(arr,containvalue);
  }
  end=system.nanotime();
  system.out.println("using set->"+(end-start)/10000);
  //using loop
  start = system.nanotime();
  for (int i = 0; i < 10000; i++) {
    useloop(arr,containvalue);
  }
  end=system.nanotime();
  system.out.println("using loop->"+(end-start)/10000);
  //using utils
  start = system.nanotime();
  for (int i = 0; i < 10000; i++) {
    useutils(arr,containvalue);
  }
  end=system.nanotime();
  system.out.println("using utils->"+(end-start)/10000);
}

  结果如下图:

using list->973
using set->2676
using loop->448
using utils->1364

 使用的jdk版本为jdk1.8.0_172版本,由上面可以推断出来

以上四种方法的效率高->低

loop>list>utils>set

对比之下,其实可以看出,采用loop方法进行判断的效率最高,再过去list,再过去utils再过去set

总结:

分析一下慢的原因:

loop最快,直接操作array,毫无疑问

list次之,由于需要创建一个java.util.array.arraylist,创建对象需要时间所以会更慢一些

util第三,由于其虽然使用的和loop差不多,但是array.getclass().getcomponenttype().isinstance(objecttofind),该段代码采用调用了本地native方法,我们知道,通过调用本地native方法会比直接调用java方法更加耗时。而且查看源码可知getclass()与getcomponenttype()以及isinstance都是native方法,非常耗时

set最差,由于其先将array转换成list,再讲list转换成set,在set中又是采用hashmap来实现的,由于其多次转换对象,自然,效率也肯定好不到哪里去了。

其实我个人还是比较喜欢使用arrayutils进行操作,虽然说相对相率低一点,但是还会不会差很多。 

以上所述是小编给大家介绍的详解java中数组判断元素存在几种方式比较,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持! 

原文链接:https://www.cnblogs.com/lonecloud/p/9290013.html

标签:

相关文章

热门资讯

2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
2021德云社封箱演出完整版 2021年德云社封箱演出在线看
2021德云社封箱演出完整版 2021年德云社封箱演出在线看 2021-03-15
返回顶部