Imagine you are building a product search feature for an online store. You want to help users quickly find products by filtering a list of product names. For instance, you might want to find all products that start with the letter "S". Instead of hardcoding the filtering logic, you decide to create a custom predicate interface that allows you to pass any filtering condition as a lambda expression. This makes your code flexible and reusable for different search criteria.

package com.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;

import java.util.List;
import java.util.Collections;

import static org.junit.jupiter.api.Assertions.*;

public class MainTest {

    @Test
    @DisplayName("Returns only strings that satisfy the predicate")
    void testFilterMatchingPredicate() {
        List<String> input = List.of("Apple", "Banana", "Avocado", "Berry");
        List<String> expected = List.of("Apple", "Avocado");
        List<String> result = Main.filterByPredicate(input, s -> s.startsWith("A"));
        assertEquals(expected, result, "Should return only items starting with 'A'");
    }

    @Test
    @DisplayName("Returns empty list if no strings match the predicate")
    void testFilterNoMatch() {
        List<String> input = List.of("Cat", "Dog", "Elephant");
        List<String> result = Main.filterByPredicate(input, s -> s.startsWith("Z"));
        assertTrue(result.isEmpty(), "Should return empty list when no items match");
    }

    @Test
    @DisplayName("Returns all items if predicate is always true")
    void testFilterAllMatch() {
        List<String> input = List.of("One", "Two", "Three");
        List<String> result = Main.filterByPredicate(input, s -> true);
        assertEquals(input, result, "Should return all items when predicate always true");
    }

    @Test
    @DisplayName("Returns empty list if input list is empty")
    void testFilterEmptyInput() {
        List<String> input = Collections.emptyList();
        List<String> result = Main.filterByPredicate(input, s -> s.length() > 0);
        assertTrue(result.isEmpty(), "Should return empty list for empty input");
    }
}


MainTest.java

Master the power of lambda expressions in Java to write concise, expressive, and modern code. This course guides you from the basics of functional interfaces to advanced lambda usage, including real-world applications and best practices.

Learn the fundamentals of lambda expressions, their syntax, and how they fit into Java's type system.

Dive deeper into lambda expressions with method references, composition, and practical applications in collections.

Learn how to write clean, efficient, and maintainable code with lambda expressions in real-world scenarios.

Challenge: Implement a Custom Predicate

解答