Desbravando a Programação Funcional no Java: Consumer, Supplier, Predicate,BinaryOperator e Mais! 🔮

A programação funcional no Java trouxe diversas interfaces e classes que facilitam a manipulação de dados de forma eficiente e expressiva. Entre elas, destacam-se Consumer, Supplier, Predicate, BinaryOperator, as operações da Stream API e a classe Optional. Vamos explorar cada uma delas! 🚀

Consumer: Executando Ações sem Retorno 🚨

A interface funcional Consumer aceita um argumento e executa uma ação sobre ele, sem retornar valor.

Exemplo:

import java.util.function.Consumer;

public class ConsumerExample {
  public static void main(String[] args) {
      Consumer<String> imprimir = s -> System.out.println("Olá, " + s + "!");
      imprimir.accept("Java"); // Saída: Olá, Java!
  }
}

Supplier: Fornecendo Valores Sob Demanda 📦

A interface Supplier não recebe parâmetros, mas retorna um valor do tipo especificado.

Exemplo:

import java.util.function.Supplier;

public class SupplierExample {
  public static void main(String[] args) {
      Supplier<Double> randomNumber = () -> Math.random();
      System.out.println(randomNumber.get());
  }
}

Predicate: Testando Condições 🛡️

A interface Predicate recebe um argumento e retorna um boolean, ideal para filtros e validações.

Exemplo:

import java.util.function.Predicate;

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

BinaryOperator: Operando sobre Dois Valores 🪨

O BinaryOperator recebe dois argumentos do mesmo tipo e retorna um resultado do mesmo tipo.

Exemplo:

import java.util.function.BinaryOperator;

public class BinaryOperatorExample {
  public static void main(String[] args) {
      BinaryOperator<Integer> soma = (a, b) -> a + b;
      System.out.println(soma.apply(10, 5)); // 15
  }
}

Stream API: Manipulação Eficiente de Coleções ♻️

A Stream API permite processar coleções de forma funcional e eficiente.

Exemplo com filter() e map():

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

public class StreamExample {
  public static void main(String[] args) {
      List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
      List<Integer> quadrados = numeros.stream()
                                       .filter(n -> n % 2 != 0)
                                       .map(n -> n * n)
                                       .collect(Collectors.toList());
      System.out.println(quadrados); // [1, 9, 25]
  }
}

Optional: Evitando NullPointerException 🛡️

A classe Optional ajuda a lidar com valores que podem ser null, evitando exceções indesejadas.

Exemplo:

import java.util.Optional;

public class OptionalExample {
  public static void main(String[] args) {
      Optional<String> nome = Optional.ofNullable(null);
      System.out.println(nome.orElse("Valor padrão")); // Saída: Valor padrão
  }
}

Conclusão: O Poder da Programação Funcional no Java 🚀

Com Consumer, Supplier, Predicate, BinaryOperator, Stream API e Optional, o Java se torna mais expressivo e poderoso. Essas ferramentas ajudam a reduzir código boilerplate e a tornar as soluções mais elegantes.

Agora é sua vez! Qual dessas funcionalidades você mais usa no seu dia a dia? Comente e compartilhe suas experiências! 💬