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