Java List查找

Java中的List是一種常用的集合類型，它提供了豐富的操作方法，包括添加元素、刪除元素、查找元素等。其中，查找元素是經常會使用到的操作，本文將從多個方面對Java List查找做詳細闡述。

一、基礎查找

Java List提供了多種基礎查找方法，如contains()、indexOf()、lastIndexOf()等。

contains()方法用於判斷List中是否包含某個元素，其函數原型為：

public boolean contains(Object o)

示例代碼如下：

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
boolean aIsExist = list.contains("A");
if (aIsExist) {
    System.out.println("A is exist.");
} else {
    System.out.println("A is not exist.");
}

上面的代碼中，我們創建了一個包含”A”、”B”、”C”三個元素的List，調用contains()方法判斷”A”是否存在。

indexOf()和lastIndexOf()方法用於查找某個元素在List中的位置，區別在於indexOf()從前往後查找，lastIndexOf()從後往前查找。它們的函數原型分別為：

public int indexOf(Object o)
public int lastIndexOf(Object o)

示例代碼如下：

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("A");
int firstAIndex = list.indexOf("A");
int lastAIndex = list.lastIndexOf("A");
System.out.println("First A index is " + firstAIndex + ", last A index is " + lastAIndex);

上面的代碼中，我們創建了一個包含”A”、”B”、”A”三個元素的List，調用indexOf()和lastIndexOf()方法查找”A”的位置。

二、自定義查找

如果默認提供的查找方法無法滿足需求，我們可以自定義查找方法。自定義查找方法通常需要兩個步驟：1、定義一個接口或抽象類；2、根據實際需求實現接口或抽象類。

下面是一個自定義查找接口的示例：

public interface ListSearcher<T> {
    int search(List<T> list, T target);
}

這個接口有一個search()方法，用於在List中查找目標元素的位置。

我們需要根據實際需求實現這個接口，下面是一個實現示例：假設我們有一個Person類：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

現在我們要在一個包含Person元素的List中查找一個age等於18的Person對象。實現代碼如下：

public class PersonSearcher implements ListSearcher<Person> {
    @Override
    public int search(List<Person> list, Person target) {
        int size = list.size();
        for (int i = 0; i < size; i++) {
            Person person = list.get(i);
            if (person.getAge() == target.getAge()) {
                return i;
            }
        }
        return -1;
    }
}

上面的代碼中，我們創建了一個PersonSearcher類，實現了ListSearcher接口，使用for循環遍歷List中的元素，如果找到了目標元素則返回其位置，否則返回-1。

使用示例代碼如下：

List<Person> list = new ArrayList<>();
list.add(new Person("A", 18));
list.add(new Person("B", 20));
list.add(new Person("C", 18));
PersonSearcher searcher = new PersonSearcher();
Person target = new Person("", 18); // 只用age作為查找條件，name可以為空
int index = searcher.search(list, target);
if (index != -1) {
    System.out.println("Target is in " + index);
} else {
    System.out.println("Target is not exist.");
}

上面的代碼中，我們創建了一個包含三個Person元素的List，使用PersonSearcher查找age等於18的Person對象。

三、Lambda表達式查找

Java 8中引入了Lambda表達式，可以使用Lambda表達式來簡化代碼。假設我們有一個List<String>，我們要查找所有以”A”開頭的元素，可以使用Lambda表達式實現：

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
list.add("Amy");
list.add("Andy");
list.add("Alex");
List<String> result = list.stream()
        .filter(s -> s.startsWith("A"))
        .collect(Collectors.toList());
System.out.println(result);

上面的代碼中，我們通過stream()方法將List轉換成Stream對象，在Stream對象上使用filter()方法過濾出以”A”開頭的元素，最後使用collect()方法將結果轉換成List形式輸出。

四、並發查找

如果我們的List比較大，單線程查找有可能會很慢，可以使用並發查找來提升性能。

Java提供了多種並發容器，如ConcurrentHashMap、CopyOnWriteArrayList等，在這裡我們使用並發查找的核心類——ForkJoinPool。

假設我們有一個很大的List，我們要查找其中所有以”A”開頭的元素，使用ForkJoinPool可以將這個大任務分割成多個小任務，分別在不同的線程中並發執行，從而提升查找速度。

示例代碼如下：

List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
    list.add(UUID.randomUUID().toString());
}
long start = System.currentTimeMillis();
ForkJoinPool pool = new ForkJoinPool();
List<String> result = pool.invoke(new FindTask(list, "A"));
long end = System.currentTimeMillis();
System.out.println("Time cost is " + (end - start) + "ms, result size is " + result.size());

上面的代碼中，我們先創建了一個包含10000個隨機字符串的List，然後使用ForkJoinPool執行查找任務，最後打印出結果的數量和執行時間。

FindTask是我們自定義的查找任務類，其實現代碼如下：

public class FindTask extends RecursiveTask<List<String>> {
    private List<String> list;
    private String prefix;

    public FindTask(List<String> list, String prefix) {
        this.list = list;
        this.prefix = prefix;
    }

    @Override
    protected List<String> compute() {
        List<String> result = new ArrayList<>();
        if (list.size() <= 100) { // 小任務直接計算
            for (String s : list) {
                if (s.startsWith(prefix)) {
                    result.add(s);
                }
            }
            return result;
        } else { // 大任務分割成小任務並繼續拆分
            int mid = list.size() / 2;
            FindTask leftTask = new FindTask(list.subList(0, mid), prefix);
            FindTask rightTask = new FindTask(list.subList(mid, list.size()), prefix);
            leftTask.fork();
            rightTask.fork();
            List<String> leftResult = leftTask.join();
            List<String> rightResult = rightTask.join();
            result.addAll(leftResult);
            result.addAll(rightResult);
            return result;
        }
    }
}

上面的代碼中，我們判斷任務是否小於等於100，如果是則直接計算，否則將任務分割成兩個小任務，分別在不同的線程中並發執行，最後將結果合併。

總結

Java List提供了多種查找方法，包括基礎查找、自定義查找、Lambda表達式查找和並發查找。我們可以根據實際需求選擇不同的方式來進行查找操作，提高代碼的性能和可讀性。