Java數組操作方法收集（快速判斷某個值在這個數組中）

Java數組操作最高效的方式是循環取值，如果轉換成集合那么就會分配內存，效率不如前者，但是方法多，需要在性能調優上去權衡。切記：數組是數組，集合是集合。

下面是收集最常用的數組轉成集合的操作方法：

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

//檢查數組是否包含某個值的方法
public class TestArray {
    // 使用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;
    }

    // 查找有序數組中是否包含某個值的用法
    public static boolean useArraysBinarySearch(String[] arr, String targetValue) {
        int a = Arrays.binarySearch(arr, targetValue);
        if (a > 0)
            return true;
        else
            return false;
    }

    // 使用ArrayUtils
    public static boolean useArrayUtils(String[] arr, String targetValue) {
        return ArrayUtils.contains(arr, targetValue);
    }

    public static void main(String[] args) {
        String[] arr = new String[] { "CD", "BC", "EF", "DE", "AB", "JK" };
        // 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
        long startTime2 = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useSet(arr, "A");
        }
        long endTime2 = System.nanoTime();
        long duration2 = endTime2 - startTime2;
        System.out.println("useSet:" + duration / 1000000);
        // use loop
        long startTime3 = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useLoop(arr, "A");
        }
        long endTime3 = System.nanoTime();
        long duration3 = endTime3 - startTime3;
        System.out.println("useLoop:" + duration / 1000000);
        // use Arrays.binarySearch()
        long startTime4 = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            useArraysBinarySearch(arr, "A");
        }
        long endTime4 = System.nanoTime();
        long duration4 = endTime4 - startTime4;
        System.out.println("useArraysBinarySearch:" + duration / 1000000);
    }
}
/*
 * 顯然，使用一個簡單的循環方法比使用任何集合都更加高效。許多開發人員為了方便，都使用第一種方法，但是他的效率也相對較低。
 * 因為將數組壓入Collection類型中，首先要將數組元素遍歷一遍，然后再使用集合類做其他操作。
 */

使用時要導入下面的包：

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.6</version>
</dependency>

 

參考：

http://www.cnblogs.com/ipetergo/p/6429747.html（以上內容轉自此篇文章）

http://www.importnew.com/18700.html