Use the built-in interfaces included in the java.util.function package such as Predicate

📦 O que é o pacote java.util.function?

Esse pacote contém interfaces funcionais (com apenas um método abstrato) que são usadas com lambdas, especialmente com Streams.

🔍 O foco principal agora: Predicate<T>

@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t);
}
  • Um Predicate<T> recebe um parâmetro do tipo T e retorna true ou false.
  • Muito usado com métodos de filtro (filter, removeIf, etc).

✅ Exemplo básico com Predicate

Predicate<String> começaComA = s -> s.startsWith("A");

System.out.println(começaComA.test("Ana")); // true
System.out.println(começaComA.test("Bruno")); // false

Comentário (linha 1):
Criamos um predicate que retorna true se a string começar com “A”.

✅ Usando Predicate com Stream

List<String> nomes = Arrays.asList("Ana", "Bruno", "Alice", "Carlos");

nomes.stream()
  .filter(s -> s.startsWith("A"))
  .forEach(System.out::println); // Ana, Alice

Comentário (linha 4):
Usamos um Predicate dentro do filter para exibir apenas nomes que começam com “A”.

✅ Predicate com removeIf()

List<Integer> numeros = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

numeros.removeIf(n -> n % 2 == 0);

System.out.println(numeros); // [1, 3, 5]

Comentário (linha 3):
Remove os números pares usando Predicate<Integer>.

🔄 Predicados Combinados

Você pode combinar Predicates com métodos default:

MétodoSignificado
and()E lógico
or()OU lógico
negate()Negação lógica (inverte)
Predicate<String> começaComA = s -> s.startsWith("A");
Predicate<String> terminaComO = s -> s.endsWith("o");

Predicate<String> combinado = começaComA.and(terminaComO);

System.out.println(combinado.test("Antonio")); // true
System.out.println(combinado.test("Ana"));     // false

Comentário (linha 4):
Usamos .and() para combinar dois critérios.

❌ Exemplos incorretos

Predicate<String> p = s -> return s.length() > 3; 
// ❌ Não se usa 'return' com arrow sem bloco

Predicate<String> p = (s) -> s.length() > 3; 
// ✅ Correto

Predicate<String> p = null;
p.test("abc"); // ❌ NullPointerException

🧠 Quiz com 5 questões

1) Qual a função principal da interface Predicate<T>?
A) Aceita dois parâmetros e retorna boolean
B) Aceita um parâmetro e retorna boolean
C) Retorna um número inteiro
D) Cria novas instâncias

2) Qual dessas expressões cria um Predicate válido?
A) Predicate<String> p = s -> s.length();
B) Predicate<String> p = s -> s.length() > 3;
C) Predicate<String> p = s -> { return; };
D) Predicate<String> p = () -> true;

3) O que faz .removeIf(n -> n < 0) em uma lista de inteiros?
A) Remove valores positivos
B) Remove valores negativos
C) Retorna true se todos forem positivos
D) Remove todos os valores

4) O que retorna Predicate<String> p = s -> s.contains("x"); p.test("taxi");
A) true
B) false
C) “taxi”
D) null

5) Qual método é usado para inverter a lógica de um Predicate?
A) reverse()
B) negate()
C) flip()
D) not()

✅ Gabarito comentado

  1. B – Predicate aceita um parâmetro e retorna boolean
  2. B – A expressão correta compara com > 3
  3. B – Remove os elementos menores que zero
  4. A – "taxi" contém "x", então retorna true
  5. B – negate() inverte o valor lógico do Predicate

🎯 Resumo final

  • Predicate<T> é usado para testes booleanos
  • Muito útil com filter, removeIf, stream().anyMatch(), etc.
  • Pode ser combinado com and(), or() e negate()
  • É essencial dominar Predicate para trabalhar com Streams de forma eficiente

Deixe um comentário