Java Academy · Aula

Function e BiFunction

Transforme valores de forma funcional.

Function e BiFunction é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que Function representa

Function<T, R> é a interface central de transformação em java.util.function. Ela recebe um argumento do tipo T e retorna um resultado do tipo R.

Seu único método abstrato é R apply(T t).
Ela representa um mapeamento puro da entrada para a saída.

import java.util.function.Function;

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

Chamando apply

Você invoca uma Function chamando apply. O corpo da lambda contém a lógica de transformação.

Os tipos de entrada e saída podem ser diferentes.
Uma referência de método como String::toUpperCase pode substituir uma lambda.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> upper = String::toUpperCase;
        System.out.println(upper.apply("java"));
    }
}

Composição com andThen

andThen encadeia funções: o resultado da primeira torna-se a entrada da segunda.

f.andThen(g) significa g(f(x)).
A leitura ocorre da esquerda para a direita.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.andThen(plus3).apply(5));
    }
}

Composição com compose

compose executa primeiro a função recebida como argumento.

f.compose(g) significa f(g(x)).
É a imagem espelhada de andThen.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.compose(plus3).apply(5));
    }
}

Function.identity

Function.identity() retorna uma função que devolve sua entrada sem alterações.

É útil em coletores de fluxos e mapeamentos padrão.
É equivalente a x -> x.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> id = Function.identity();
        System.out.println(id.apply("unchanged"));
    }
}

Conheça BiFunction

BiFunction<T, U, R> recebe dois argumentos e retorna um resultado.

Seu método é R apply(T t, U u).
É excelente para combinar dois valores, como ao mesclar mapas.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(4, 6));
    }
}

BiFunction com tipos diferentes

Os três parâmetros de tipo de BiFunction podem ser todos diferentes.

Aqui combinamos uma String e um int em uma String.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
        System.out.println(repeat.apply("ab", 3));
    }
}

BiFunction e andThen

BiFunction também aceita andThen, recebendo uma Function de um único argumento para pós-processar o resultado.

Não existe compose em BiFunction, pois seriam necessárias duas entradas.

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        Function<Integer, String> label = n -> "sum=" + n;
        System.out.println(add.andThen(label).apply(7, 8));
    }
}

Funções em coleções

Muitas APIs aceitam uma Function. Por exemplo, Map.computeIfAbsent recebe uma função de mapeamento para chaves ausentes.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> lengths = new HashMap<>();
        lengths.computeIfAbsent("hello", String::length);
        System.out.println(lengths);
    }
}

Armazenando funções em variáveis

Como as funções são objetos, você pode armazená-las, passá-las e retorná-las. Essa é a base do Java em estilo funcional.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> square = n -> n * n;
        Function<Integer, Integer> cube = n -> n * n * n;
        Function<Integer, Integer> chosen = square;
        System.out.println(chosen.apply(5));
    }
}

Construindo uma cadeia de transformação

Encadear andThen repetidamente cria uma cadeia de transformação legível e reutilizável.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> trim = String::trim;
        Function<String, String> upper = String::toUpperCase;
        Function<String, Integer> len = String::length;
        System.out.println(trim.andThen(upper).andThen(len).apply("  abc "));
    }
}

Verificação rápida

O que f.andThen(g).apply(x) calcula?

Recapitulação

Você aprendeu as principais interfaces de transformação:

Function<T,R> mapeia um valor com apply.
andThen encadeia para frente (g(f(x))); compose encadeia para trás (f(g(x))).
Function.identity() retorna sua entrada.
BiFunction<T,U,R> trata duas entradas e aceita andThen, mas não compose.

Perguntas Frequentes

A aula “Function e BiFunction” é grátis?

Sim — o texto completo de “Function e BiFunction” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Function e BiFunction”?

Transforme valores de forma funcional. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Function e BiFunction”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy