您如何在Java中的數組中搜索元素？

在Java中搜索數組元素的最佳方法取決於數組是否已排序及性能需求：對於未排序的小數組，使用線性搜索（時間複雜度O(n)）；對於已排序數組，使用Arrays.binarySearch()（時間複雜度O(log n)）；若使用對像數組且追求簡潔，可轉為List後調用contains()或indexOf()；在Java 8 中偏好函數式風格時，可使用Arrays.stream().anyMatch()實現簡潔的一行代碼，但性能略低於傳統循環，因此選擇方法需權衡性能、可讀性和數據是否排序的情況。

In Java, searching for an element in an array depends on whether the array is sorted or not, and what kind of performance or simplicity you're aiming for. Here are the most common and practical ways:

1. Linear Search (for unsorted arrays)

If the array isn't sorted, the simplest approach is to loop through each element until you find a match.

 int[] arr = {10, 20, 30, 40, 50};
int target = 30;
boolean found = false;

for (int i = 0; i < arr.length; i ) {
    if (arr[i] == target) {
        System.out.println("Element found at index " i);
        found = true;
        break;
    }
}
if (!found) {
    System.out.println("Element not found");
}

• Works with any array, sorted or not.
• Time complexity: O(n).
• Best when the array is small or unsorted.

2. Binary Search (for sorted arrays)

If the array is sorted, you can use binary search for better performance.

You can use the built-in method from Arrays.binarySearch() :

 import java.util.Arrays;

int[] arr = {10, 20, 30, 40, 50};
int target = 30;

int index = Arrays.binarySearch(arr, target);

if (index >= 0) {
    System.out.println("Element found at index " index);
} else {
    System.out.println("Element not found");
}

• Only works on sorted arrays.
• Time complexity: O(log n).
• If the array isn't sorted, sort it first using Arrays.sort(arr) — but that adds O(n log n) overhead.

⚠️ Important: If you use binarySearch on an unsorted array, the result is undefined.

3. Using ArrayList or Collections (alternative approach)

If you're open to using collections instead of raw arrays, you can convert the array to a List and use contains() or indexOf() :

 import java.util.Arrays;
import java.util.List;

Integer[] arr = {10, 20, 30, 40, 50};
List<Integer> list = Arrays.asList(arr);

if (list.contains(30)) {
    System.out.println("Element found");
}

• contains() returns true or false .
• list.indexOf(30) returns the index or -1 if not found.
• Note: Works with wrapper types ( Integer[] ), not primitive arrays like int[] .

4. Using Streams (Java 8 )

Modern Java allows using streams for more readable one-liners:

 import java.util.Arrays;

int[] arr = {10, 20, 30, 40, 50};
boolean found = Arrays.stream(arr).anyMatch(x -> x == 30);

if (found) {
    System.out.println("Element found");
}

• anyMatch() returns true if any element matches.
• You can also use IntStream for more operations.
• Slightly more overhead than a simple loop, but clean and functional in style.

So, the best method depends on your situation:

• Unsorted array, small size : Use linear search (simple loop).
• Sorted array : Use Arrays.binarySearch() .
• Want clean syntax and using objects : Convert to List and use contains .
• Using Java 8 and prefer functional style : Use Arrays.stream() .

Basically, it's about trade-offs between performance, readability, and whether the data is sorted.

以上是您如何在Java中的數組中搜索元素？的詳細內容。更多資訊請關注PHP中文網其他相關文章！