JavaのStream APIを使った複数条件での効率的なフィルタリング方法

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());

List<String> strings = Arrays.asList("apple", "banana", "cherry", "date");
List<String> filteredStrings = strings.stream()
                                      .filter(s -> s.contains("a"))
                                      .collect(Collectors.toList());

List<User> users = Arrays.asList(
    new User("Alice", 28),
    new User("Bob", 35),
    new User("Charlie", 40),
    new User("David", 30)
);

List<User> filteredUsers = users.stream()
    .filter(user -> user.getAge() >= 30)
    .filter(user -> user.getName().startsWith("A"))
    .collect(Collectors.toList());

List<User> filteredUsers = users.stream()
    .filter(user -> user.getAge() >= 30 || user.getName().startsWith("B"))
    .collect(Collectors.toList());

List<User> filteredUsers = users.stream()
    .filter(user -> user.getAge() >= 30 && (user.getName().startsWith("B") || user.getName().startsWith("C")))
    .collect(Collectors.toList());

List<User> filteredUsers = users.stream()
    .filter(user -> user.getAge() >= 30)
    .filter(user -> user.getName().startsWith("A"))
    .collect(Collectors.toList());

List<User> filteredUsers = users.stream()
    .filter(user -> user.getAge() >= 30 && user.getName().startsWith("B"))
    .collect(Collectors.toList());

List<User> filteredUsers = users.parallelStream()
    .filter(user -> user.getAge() >= 30)
    .filter(user -> user.getName().startsWith("A"))
    .collect(Collectors.toList());

public class CustomUserFilter implements Predicate<User> {
    @Override
    public boolean test(User user) {
        return user.getAge() >= 30 && user.getName().startsWith("B") && user.getRegistrationDate().isAfter(LocalDate.of(2020, 1, 1));
    }
}

List<User> users = // ユーザーリストの初期化
Predicate<User> customFilter = new CustomUserFilter();

List<User> filteredUsers = users.stream()
    .filter(customFilter)
    .collect(Collectors.toList());

public class FlexibleUserFilter implements Predicate<User> {
    private final int minAge;
    private final String namePrefix;
    private final LocalDate registrationAfter;

    public FlexibleUserFilter(int minAge, String namePrefix, LocalDate registrationAfter) {
        this.minAge = minAge;
        this.namePrefix = namePrefix;
        this.registrationAfter = registrationAfter;
    }

    @Override
    public boolean test(User user) {
        return user.getAge() >= minAge && user.getName().startsWith(namePrefix) && user.getRegistrationDate().isAfter(registrationAfter);
    }
}

Predicate<User> customFilter = new FlexibleUserFilter(30, "B", LocalDate.of(2020, 1, 1));

List<User> filteredUsers = users.stream()
    .filter(customFilter)
    .collect(Collectors.toList());

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import java.util.List;

public class UserFilterTest {

    @Test
    public void testFilterUsers() {
        List<User> users = // ユーザーリストの初期化
        Predicate<User> customFilter = new FlexibleUserFilter(30, "B", LocalDate.of(2020, 1, 1));

        List<User> filteredUsers = users.stream()
                                        .filter(customFilter)
                                        .collect(Collectors.toList());

        // 期待される結果のリストと比較
        assertEquals(2, filteredUsers.size());
        assertTrue(filteredUsers.stream().allMatch(user -> user.getAge() >= 30));
        assertTrue(filteredUsers.stream().allMatch(user -> user.getName().startsWith("B")));
    }
}

List<User> filteredUsers = users.stream()
    .filter(user -> {
        boolean result = user.getAge() >= 30;
        System.out.println("Age check for " + user.getName() + ": " + result);
        return result;
    })
    .filter(user -> {
        boolean result = user.getName().startsWith("B");
        System.out.println("Name check for " + user.getName() + ": " + result);
        return result;
    })
    .collect(Collectors.toList());

List<Customer> targetCustomers = customers.stream()
    .filter(customer -> customer.getAge() >= 25 && customer.getAge() <= 40)
    .filter(customer -> customer.getPurchaseHistory().contains("Electronics"))
    .filter(customer -> customer.getRegion().equals("Tokyo"))
    .collect(Collectors.toList());

List<Product> reorderProducts = products.stream()
    .filter(product -> product.getStock() < 50)
    .filter(product -> product.getSalesLastMonth() > 100)
    .collect(Collectors.toList());

List<Customer> highRiskCustomers = customers.stream()
    .filter(customer -> customer.getCreditScore() < 600)
    .filter(customer -> customer.getAnnualIncome() < 30000)
    .filter(customer -> customer.getPaymentHistory().contains("Late"))
    .collect(Collectors.toList());

List<Candidate> shortlistedCandidates = candidates.stream()
    .filter(candidate -> candidate.getExperienceYears() >= 5)
    .filter(candidate -> candidate.getSkills().contains("Java"))
    .filter(candidate -> candidate.getPreferredLocation().equals("Remote"))
    .collect(Collectors.toList());

// 商品クラスの定義
public class Product {
    private String name;
    private double price;
    private int stock;
    private String category;

    // コンストラクタ、ゲッター、セッターは省略

    public Product(String name, double price, int stock, String category) {
        this.name = name;
        this.price = price;
        this.stock = stock;
        this.category = category;
    }

    // ゲッターメソッド（省略）
}

// 演習問題1のフィルタリングコード
List<Product> products = Arrays.asList(
    new Product("Laptop", 1200.0, 50, "Electronics"),
    new Product("Book", 30.0, 150, "Books"),
    new Product("Phone", 800.0, 200, "Electronics"),
    new Product("Notebook", 10.0, 500, "Stationery")
);

List<Product> filteredProducts = products.stream()
    .filter(product -> product.getPrice() >= 50)
    .filter(product -> product.getStock() >= 100)
    .filter(product -> product.getCategory().equals("Electronics") || product.getCategory().equals("Books"))
    .collect(Collectors.toList());

// ユーザークラスの定義
public class User {
    private String name;
    private int age;
    private boolean isMember;

    // コンストラクタ、ゲッター、セッターは省略

    public User(String name, int age, boolean isMember) {
        this.name = name;
        this.age = age;
        this.isMember = isMember;
    }

    // ゲッターメソッド（省略）
}

// 演習問題2のフィルタリングコード
List<User> users = Arrays.asList(
    new User("Alice", 30, true),
    new User("Bob", 45, true),
    new User("Charlie", 28, false),
    new User("Alex", 35, true)
);

List<User> filteredUsers = users.stream()
    .filter(user -> user.getAge() >= 25 && user.getAge() <= 40)
    .filter(user -> user.getName().startsWith("A"))
    .filter(User::isMember)
    .collect(Collectors.toList());

// 注文クラスの定義
public class Order {
    private double amount;
    private LocalDate orderDate;
    private String status;

    // コンストラクタ、ゲッター、セッターは省略

    public Order(double amount, LocalDate orderDate, String status) {
        this.amount = amount;
        this.orderDate = orderDate;
        this.status = status;
    }

    // ゲッターメソッド（省略）
}

// 演習問題3のフィルタリングコード
List<Order> orders = Arrays.asList(
    new Order(150.0, LocalDate.now().minusDays(3), "Shipped"),
    new Order(50.0, LocalDate.now().minusDays(1), "Processing"),
    new Order(200.0, LocalDate.now().minusDays(10), "Shipped"),
    new Order(120.0, LocalDate.now().minusDays(5), "Shipped")
);

List<Order> filteredOrders = orders.stream()
    .filter(order -> order.getAmount() >= 100)
    .filter(order -> order.getOrderDate().isAfter(LocalDate.now().minusDays(7)))
    .filter(order -> order.getStatus().equals("Shipped"))
    .collect(Collectors.toList());