詳解Java中數(shù)組判斷元素存在幾種方式比較

更新時間：2018年07月11日 09:37:35 作者：lonecloud

這篇文章主要介紹了Java中數(shù)組判斷元素存在幾種方式比較，非常不錯，具有一定的參考借鑒價值，需要的朋友參考下吧

1. 通過將數(shù)組轉(zhuǎn)換成List，然后使用List中的contains進行判斷其是否存在

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

　需要注意的是Arrays.asList這個方法中轉(zhuǎn)換的List并不是java.util.ArrayList而是java.util.Arrays.ArrayList，其中java.util.Arrays.ArrayList中不能對數(shù)組的長度進行擴容操作，這個尤為重要，其中contains實現(xiàn)如下：

@Override
public boolean contains(Object o) {
  //調(diào)用indexOf方法判斷其在那個位置，判斷其時候為-1
   return indexOf(o) != -1;
}
@Override
public int indexOf(Object o) {
  //獲取元素
  E[] a = this.a;
  //判斷空
  if (o == null) {
    //循環(huán)判斷
    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進行實現(xiàn)判斷是否存在

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

　　原理將數(shù)組->List->Set使用Set進行比較

源碼：通過調(diào)用map的containsKey實現(xiàn)的,而hashmap中則是通過遍歷hash表中的key實現(xiàn)

ypublic boolean contains(Object o) {
    return map.containsKey(o);
  }

3. 使用循環(huán)來實現(xiàn)，自己編寫一個循環(huán)來判斷

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方法來實現(xiàn)

public static boolean useUtils(String[] arr,String containValue){
    return ArrayUtils.contains(arr,containValue);
  }

具體實現(xiàn)源碼：

public static boolean contains(final Object[] array, final Object objectToFind) {
    //調(diào)用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則直接使用==進行循環(huán)判斷位置
      for (int i = startIndex; i < array.length; i++) {
        if (array[i] == null) {
          return i;
        }
      }
     //判斷元素是不是array中的元素的實例，如果是則循環(huán)并采用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;
  }

　　使用循環(huán)1w次來檢測效率

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);
}

　　結(jié)果如下圖：

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

總結(jié)：

分析一下慢的原因：

loop最快，直接操作array，毫無疑問

list次之，由于需要創(chuàng)建一個java.util.Array.ArrayList,創(chuàng)建對象需要時間所以會更慢一些

util第三，由于其雖然使用的和loop差不多，但是array.getClass().getComponentType().isInstance(objectToFind)，該段代碼采用調(diào)用了本地native方法，我們知道，通過調(diào)用本地native方法會比直接調(diào)用java方法更加耗時。而且查看源碼可知getClass()與getComponentType()以及isInstance都是native方法，非常耗時

set最差，由于其先將Array轉(zhuǎn)換成List，再講list轉(zhuǎn)換成Set,在Set中又是采用HashMap來實現(xiàn)的，由于其多次轉(zhuǎn)換對象，自然，效率也肯定好不到哪里去了。

其實我個人還是比較喜歡使用ArrayUtils進行操作，雖然說相對相率低一點，但是還會不會差很多?！?/p>

以上所述是小編給大家介紹的詳解Java中數(shù)組判斷元素存在幾種方式比較，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！　

您可能感興趣的文章: