如何检查一个数组中是否有某个值？

如何检查一个没有排序的数组中是否含有某个值？这个操作在Java中经常使用，也是很有用的；但采取的方式不同，时间复杂度也不同；

 

以下提供了4种方式： 

1）使用List： 

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

  

 2）使用Set： 

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

  

3）使用一个简单的循环： 

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

  

4）使用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;
}

 

 

 时间复杂度： 

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

 

使用一个大一点的数组呢？（1K）

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

 

使用一个再大点的数组呢？（10K） 

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

 

很明显，使用简单的for循环是最高效的。

如果使用Arrays.binarySearch()，那数组必须是已经排序。

 

事实上，一个已经排序的 List 或者 Tree 复杂度为O(log(n))，  HashSet 为O(1)