0Pricing
Java Academy · Lekcja

Predicate i kompozycja

Komponowanie testów logicznych

Predicate i kompozycja to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Działanie Predicate

Predicate<T> przyjmuje wartość i zwraca wartość typu boolean.

  • Jego metoda to boolean test(T t).
  • Modeluje warunek typu tak/nie.
import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        System.out.println(isEven.test(4));
        System.out.println(isEven.test(5));
    }
}

Predicate w filter

Stream.filter przyjmuje Predicate i zachowuje wyłącznie pasujące elementy.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6);
        List<Integer> evens = nums.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println(evens);
    }
}

Łączenie za pomocą and

and tworzy predykat, który jest prawdziwy tylko wtedy, gdy oba predykaty spełnią warunek.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<Integer> positive = n -> n > 0;
        Predicate<Integer> even = n -> n % 2 == 0;
        Predicate<Integer> both = positive.and(even);
        System.out.println(both.test(4));
        System.out.println(both.test(-2));
    }
}

Łączenie za pomocą or

or zwraca true, gdy warunek spełni co najmniej jeden predykat.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<String> empty = String::isEmpty;
        Predicate<String> shortStr = s -> s.length() < 3;
        Predicate<String> either = empty.or(shortStr);
        System.out.println(either.test(""));
        System.out.println(either.test("hi"));
        System.out.println(either.test("hello"));
    }
}

Negowanie za pomocą negate

negate odwraca wynik predykatu, zapewniając logiczne zaprzeczenie NOT.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<Integer> even = n -> n % 2 == 0;
        Predicate<Integer> odd = even.negate();
        System.out.println(odd.test(3));
    }
}

Statyczny pomocnik Predicate.not

Predicate.not(p) to czytelny, statyczny sposób negowania predykatu, szczególnie przy użyciu referencji do metod.

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("", "a", "", "bc");
        List<String> nonEmpty = words.stream()
            .filter(Predicate.not(String::isEmpty))
            .collect(Collectors.toList());
        System.out.println(nonEmpty);
    }
}

Predicate.isEqual

Predicate.isEqual(target) tworzy predykat sprawdzający równość z ustaloną wartością za pomocą Objects.equals.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<String> isJava = Predicate.isEqual("java");
        System.out.println(isJava.test("java"));
        System.out.println(isJava.test("python"));
    }
}

Łączenie wielu warunków

Można łączyć and, or i negate, aby wyrażać złożone reguły. Nawiasy pozwalają kontrolować grupowanie warunków.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<Integer> big = n -> n > 100;
        Predicate<Integer> even = n -> n % 2 == 0;
        Predicate<Integer> rule = big.and(even).or(n -> n == 0);
        System.out.println(rule.test(0));
        System.out.println(rule.test(102));
        System.out.println(rule.test(101));
    }
}

BiPredicate dla dwóch danych wejściowych

BiPredicate<T, U> sprawdza dwa argumenty i również obsługuje and, or oraz negate.

import java.util.function.BiPredicate;

public class Main {
    public static void main(String[] args) {
        BiPredicate<String, Integer> hasLength = (s, n) -> s.length() == n;
        System.out.println(hasLength.test("hello", 5));
    }
}

Predicates w anyMatch

Operacje końcowe strumienia, takie jak anyMatch, allMatch i noneMatch, wszystkie przyjmują Predicate.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 3, 5, 8);
        System.out.println(nums.stream().anyMatch(n -> n % 2 == 0));
        System.out.println(nums.stream().allMatch(n -> n > 0));
    }
}

Wielokrotnego użytku stałe Predicate

Zdefiniowanie predykatów jako nazwanych zmiennych sprawia, że potoki filtrowania same dokumentują swój cel i można ich ponownie używać.

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Predicate<String> nonBlank = s -> !s.isBlank();
        List<String> input = List.of("a", " ", "", "b");
        System.out.println(input.stream().filter(nonBlank).collect(Collectors.toList()));
    }
}

Szybkie sprawdzenie

Co tworzy p.and(q)?

Podsumowanie

Tworzono złożone testy logiczne:

  • Predicate<T> używa test, aby zwrócić wartość boolean.
  • and, or i negate łączą warunki z zastosowaniem ewaluacji ze skróceniem.
  • Predicate.not i Predicate.isEqual to przydatne statyczne pomocniki.
  • BiPredicate sprawdza dwa dane wejściowe.

Często zadawane pytania

Czy lekcja „Predicate i kompozycja” jest bezpłatna?

Tak — pełny tekst „Predicate i kompozycja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Predicate i kompozycja”?

Komponowanie testów logicznych Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Predicate i kompozycja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Function i BiFunction
  2. Supplier i Consumer
  3. Predicate i kompozycja
  4. Własne interfejsy funkcyjne
← Powrót do Java Academy