Java Academy · Lección

Function y BiFunction

Transforme valores de forma funcional

Function y BiFunction es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Qué representa Function

Function<T, R> es la interfaz de transformación principal de java.util.function. Recibe un argumento de tipo T y devuelve un resultado de tipo R.

Su único método abstracto es R apply(T t).
Modela una transformación pura de la entrada a la salida.

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"));
    }
}

Llamar a apply

Se invoca una Function llamando a apply. El cuerpo de la lambda contiene la lógica de transformación.

Los tipos de entrada y salida pueden ser diferentes.
Una referencia a método como String::toUpperCase puede sustituir a una 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"));
    }
}

Composición con andThen

andThen encadena funciones: el resultado de la primera se convierte en la entrada de la segunda.

f.andThen(g) significa g(f(x)).
Se lee de izquierda a derecha.

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));
    }
}

Composición con compose

compose ejecuta primero la función recibida como argumento.

f.compose(g) significa f(g(x)).
Es la imagen especular 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() devuelve una función que devuelve su entrada sin modificarla.

Es útil en collectors de streams y asignaciones predeterminadas.
Es 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"));
    }
}

Conozca BiFunction

BiFunction<T, U, R> recibe dos argumentos y devuelve un resultado.

Su método es R apply(T t, U u).
Es ideal para combinar dos valores, como al fusionar 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 con tipos mixtos

Los tres parámetros de tipo de BiFunction pueden ser diferentes.

Aquí combinamos un String y un int para obtener un 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 y andThen

BiFunction también admite andThen, que recibe una Function de un solo argumento para procesar posteriormente el resultado.

BiFunction no tiene compose porque necesitaría dos 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));
    }
}

Funciones en colecciones

Muchas API aceptan una Function. Por ejemplo, Map.computeIfAbsent recibe una función de mapeo para las claves que faltan.

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);
    }
}

Almacenar funciones en variables

Como las funciones son objetos, puede almacenarlas, pasarlas y devolverlas. Esta es la base del estilo funcional en Java.

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));
    }
}

Construcción de una canalización

Encadenar andThen repetidamente crea una canalización de transformación legible y reutilizable.

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 "));
    }
}

Comprobación rápida

¿Qué calcula f.andThen(g).apply(x)?

Recapitulación

Ha aprendido las interfaces de transformación principales:

Function<T,R> transforma un valor mediante apply.
andThen encadena hacia delante (g(f(x))); compose encadena hacia atrás (f(g(x))).
Function.identity() devuelve su entrada.
BiFunction<T,U,R> gestiona dos entradas y admite andThen, pero no compose.

Preguntas frecuentes

¿La lección «Function y BiFunction» es gratis?

Sí — el texto completo de «Function y BiFunction» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Function y BiFunction»?

Transforme valores de forma funcional Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Function y BiFunction»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy