Java集合筛选案例如何实现

本文目录导读：

1. 传统for循环筛选
2. Java 8 Stream API筛选
3. 对象筛选案例
4. 使用CollectionUtils工具类
5. 使用Google Guava
6. 性能优化：并行流筛选
7. 自定义筛选方法

我来介绍几种Java集合筛选的常用实现方法：

传统for循环筛选

import java.util.ArrayList;
import java.util.List;
public class TraditionalFilter {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }
        // 筛选大于5的数
        List<Integer> filtered = new ArrayList<>();
        for (Integer num : numbers) {
            if (num > 5) {
                filtered.add(num);
            }
        }
        System.out.println("大于5的数: " + filtered);
    }
}

Java 8 Stream API筛选

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamFilter {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
        // 筛选长度大于3的名字
        List<String> filtered = names.stream()
            .filter(name -> name.length() > 3)
            .collect(Collectors.toList());
        System.out.println("长度大于3的名字: " + filtered);
        // 链式筛选：长度大于3且包含字母a
        List<String> complexFilter = names.stream()
            .filter(name -> name.length() > 3)
            .filter(name -> name.contains("a") || name.contains("A"))
            .collect(Collectors.toList());
        System.out.println("复杂筛选结果: " + complexFilter);
    }
}

对象筛选案例

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
class Person {
    private String name;
    private int age;
    private String city;
    public Person(String name, int age, String city) {
        this.name = name;
        this.age = age;
        this.city = city;
    }
    // getters
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getCity() { return city; }
    @Override
    public String toString() {
        return name + "(" + age + "岁," + city + ")";
    }
}
public class ObjectFilter {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("张三", 25, "北京"));
        people.add(new Person("李四", 30, "上海"));
        people.add(new Person("王五", 20, "北京"));
        people.add(new Person("赵六", 35, "广州"));
        people.add(new Person("孙七", 28, "上海"));
        // 筛选出所有年龄大于25岁的人
        List<Person> adults = people.stream()
            .filter(p -> p.getAge() > 25)
            .collect(Collectors.toList());
        System.out.println("年龄大于25岁: " + adults);
        // 筛选出所有北京的人
        List<Person> beijingPeople = people.stream()
            .filter(p -> "北京".equals(p.getCity()))
            .collect(Collectors.toList());
        System.out.println("北京人: " + beijingPeople);
        // 多条件筛选：北京且年龄大于22岁
        List<Person> complexFilter = people.stream()
            .filter(p -> "北京".equals(p.getCity()) && p.getAge() > 22)
            .collect(Collectors.toList());
        System.out.println("北京且年龄>22: " + complexFilter);
    }
}

使用CollectionUtils工具类

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import java.util.ArrayList;
import java.util.List;
public class CollectionUtilsFilter {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }
        // 使用Predicate筛选偶数
        List<Integer> evens = new ArrayList<>(CollectionUtils.select(
            numbers, 
            new Predicate<Integer>() {
                @Override
                public boolean evaluate(Integer n) {
                    return n % 2 == 0;
                }
            }
        ));
        System.out.println("偶数: " + evens);
        // 筛选大于5的数
        List<Integer> greaterThan5 = new ArrayList<>(CollectionUtils.select(
            numbers,
            n -> n > 5
        ));
        System.out.println("大于5: " + greaterThan5);
    }
}

使用Google Guava

import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.List;
public class GuavaFilter {
    public static void main(String[] args) {
        List<String> cities = Lists.newArrayList("北京", "上海", "广州", "深圳", "杭州");
        // 筛选包含"京"的城市
        Collection<String> filtered = Collections2.filter(cities, 
            new Predicate<String>() {
                @Override
                public boolean apply(String city) {
                    return city.contains("京");
                }
            }
        );
        System.out.println("包含'京'的城市: " + filtered);
        // Java 8 lambda表达式
        Collection<String> filtered2 = Collections2.filter(cities, 
            city -> city.length() > 2
        );
        System.out.println("名称长度>2的城市: " + filtered2);
    }
}

性能优化：并行流筛选

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ParallelStreamFilter {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 1000000; i++) {
            numbers.add(i);
        }
        // 使用并行流提高大数据量筛选性能
        List<Integer> filtered = numbers.parallelStream()
            .filter(n -> n > 500000)
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println("筛选结果数量: " + filtered.size());
    }
}

自定义筛选方法

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class GenericFilter {
    // 通用的筛选方法
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }
        // 使用自定义筛选方法
        List<Integer> evens = filter(numbers, n -> n % 2 == 0);
        System.out.println("偶数: " + evens);
        List<Integer> odds = filter(numbers, n -> n % 2 != 0);
        System.out.println("奇数: " + odds);
    }
}

推荐使用：对于Java 8及以上版本，Stream API是最简洁、最灵活的筛选方式，它支持链式操作、并行处理，代码可读性强。