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表达式查找和并发查找。我们可以根据实际需求选择不同的方式来进行查找操作，提高代码的性能和可读性。