Java案例如何实现数据过滤？

本文目录导读：

1. 使用Stream API（Java 8+）
2. 使用Predicate接口（函数式编程）
3. 传统循环过滤方式
4. 使用Apache Commons Collections
5. 复合过滤条件实现

我来详细说明Java中实现数据过滤的几种常见方式,并附上完整案例。

使用Stream API（Java 8+）

最简单的过滤方式,适合集合数据处理。

import java.util.*;
import java.util.stream.Collectors;
public class StreamFilterDemo {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("张三", 25, "北京"),
            new Person("李四", 30, "上海"),
            new Person("王五", 18, "北京"),
            new Person("赵六", 35, "广州"),
            new Person("钱七", 28, "北京")
        );
        // 过滤出北京地区且年龄大于20岁的人
        List<Person> filtered = people.stream()
            .filter(p -> "北京".equals(p.getCity()))
            .filter(p -> p.getAge() > 20)
            .collect(Collectors.toList());
        System.out.println("过滤结果：");
        filtered.forEach(System.out::println);
        // 多条件过滤：提取年龄在20-30之间的北京人
        List<Person> complexFilter = people.stream()
            .filter(p -> p.getAge() >= 20 && p.getAge() <= 30)
            .filter(p -> "北京".equals(p.getCity()))
            .collect(Collectors.toList());
    }
}
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;
    }
    // getter和setter
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getCity() { return city; }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", city='" + city + "'}";
    }
}

使用Predicate接口（函数式编程）

Predicate提供了更灵活的过滤条件组合。

import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class PredicateFilterDemo {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
            new Product("iPhone", 6999, "电子"),
            new Product("Java书", 89, "图书"),
            new Product("耳机", 299, "电子"),
            new Product("Python书", 79, "图书"),
            new Product("电脑", 5999, "电子")
        );
        // 定义多个Predicate
        Predicate<Product> isElectronic = p -> "电子".equals(p.getCategory());
        Predicate<Product> isExpensive = p -> p.getPrice() > 500;
        Predicate<Product> nameContainsIphone = p -> p.getName().contains("iPhone");
        // 组合条件：电子类且价格大于500
        Predicate<Product> electronicAndExpensive = isElectronic.and(isExpensive);
        // 或者条件：电子类或者价格大于500
        Predicate<Product> electronicOrExpensive = isElectronic.or(isExpensive);
        // 取反条件：非电子产品
        Predicate<Product> notElectronic = isElectronic.negate();
        System.out.println("电子类且价格>500：");
        filterProducts(products, electronicAndExpensive).forEach(System.out::println);
        System.out.println("\n非电子产品：");
        filterProducts(products, notElectronic).forEach(System.out::println);
    }
    public static List<Product> filterProducts(List<Product> products, 
                                              Predicate<Product> predicate) {
        return products.stream()
            .filter(predicate)
            .collect(Collectors.toList());
    }
}
class Product {
    private String name;
    private double price;
    private String category;
    public Product(String name, double price, String category) {
        this.name = name;
        this.price = price;
        this.category = category;
    }
    // getter
    public String getName() { return name; }
    public double getPrice() { return price; }
    public String getCategory() { return category; }
    @Override
    public String toString() {
        return String.format("Product{name='%s', price=%.2f, category='%s'}", 
                           name, price, category);
    }
}

传统循环过滤方式

适合复杂逻辑或需要中断的场景。

import java.util.*;
public class TraditionalFilterDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 过滤出偶数
        List<Integer> evens = filterEvenNumbers(numbers);
        System.out.println("偶数：" + evens);
        // 复杂条件过滤
        List<String> filteredStrings = filterStringsWithComplexLogic();
        System.out.println("\n复杂过滤结果：" + filteredStrings);
    }
    private static List<Integer> filterEvenNumbers(List<Integer> numbers) {
        List<Integer> result = new ArrayList<>();
        for (Integer num : numbers) {
            if (num % 2 == 0) {
                result.add(num);
            }
        }
        return result;
    }
    // 复杂过滤逻辑：包含特定字符且长度大于3
    private static List<String> filterStringsWithComplexLogic() {
        List<String> strings = Arrays.asList("hello", "world", "hi", "java", "python");
        List<String> result = new ArrayList<>();
        for (String str : strings) {
            if (str.contains("a") || str.contains("o")) {
                if (str.length() > 3) {
                    result.add(str);
                }
            }
        }
        return result;
    }
}

使用Apache Commons Collections

需要添加依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.PredicateUtils;
import java.util.*;
public class ApacheFilterDemo {
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(new User("admin", "管理员", true));
        users.add(new User("user1", "普通用户1", false));
        users.add(new User("user2", "普通用户2", false));
        users.add(new User("test", "测试用户", true));
        // 使用Apache Commons过滤
        Predicate<User> activePredicate = user -> user.isActive();
        Predicate<User> adminPredicate = user -> "admin".equals(user.getUsername());
        // 组合条件：活跃用户或者管理员
        Predicate<User> combined = PredicateUtils.orPredicate(activePredicate, adminPredicate);
        CollectionUtils.filter(users, combined);
        System.out.println("过滤后的用户：");
        users.forEach(System.out::println);
    }
}
class User {
    private String username;
    private String displayName;
    private boolean active;
    // 构造函数、getter、setter和toString
    public User(String username, String displayName, boolean active) {
        this.username = username;
        this.displayName = displayName;
        this.active = active;
    }
    public String getUsername() { return username; }
    public boolean isActive() { return active; }
    @Override
    public String toString() {
        return String.format("User{username='%s', displayName='%s', active=%s}", 
                           username, displayName, active);
    }
}

复合过滤条件实现

多个条件的灵活组合。

import java.util.*;
import java.util.stream.Collectors;
public class ComplexFilterDemo {
    public static void main(String[] args) {
        List<Order> orders = createOrders();
        // 复杂过滤：金额>100的已完成订单，按金额排序
        List<Order> filteredOrders = orders.stream()
            .filter(o -> o.getAmount() > 100)
            .filter(o -> "已完成".equals(o.getStatus()))
            .sorted(Comparator.comparingDouble(Order::getAmount).reversed())
            .collect(Collectors.toList());
        System.out.println("复杂过滤结果：");
        filteredOrders.forEach(System.out::println);
        // 分组过滤统计
        Map<String, List<Order>> statusGroups = orders.stream()
            .collect(Collectors.groupingBy(Order::getStatus));
        System.out.println("\n按状态分组：");
        statusGroups.forEach((status, orderList) -> {
            System.out.println(status + ": " + orderList.size() + "条");
        });
    }
    private static List<Order> createOrders() {
        return Arrays.asList(
            new Order("001", 150.0, "已完成", "张三"),
            new Order("002", 50.0, "已取消", "李四"),
            new Order("003", 300.0, "已完成", "王五"),
            new Order("004", 80.0, "待支付", "赵六"),
            new Order("005", 200.0, "已完成", "钱七")
        );
    }
}
class Order {
    private String orderId;
    private double amount;
    private String status;
    private String customer;
    public Order(String orderId, double amount, String status, String customer) {
        this.orderId = orderId;
        this.amount = amount;
        this.status = status;
        this.customer = customer;
    }
    // getter
    public double getAmount() { return amount; }
    public String getStatus() { return status; }
    @Override
    public String toString() {
        return String.format("Order{id='%s', amount=%.2f, status='%s', customer='%s'}", 
                           orderId, amount, status, customer);
    }
}

推荐使用Stream API + Predicate的组合方式,原因如下：

1. 代码简洁：一行代码完成过滤
2. 可读性强：链式调用清晰表达意图
3. 易于组合：Predicate可以灵活组合
4. 性能优化：支持并行处理（parallelStream()）
5. 函数式编程：符合现代Java编程范式

建议根据实际场景选择合适的方式：

• 简单过滤：Stream API
• 复杂条件组合：Predicate
• 需要中断循环：传统方式
• 大数据量：考虑并行流或数据库查询