0Pricing
Java Academy · Lección

Referencias a métodos estáticos

Sustituya lambdas que llaman a métodos estáticos por referencias ClassName::methodName.

Referencias a métodos estáticos 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é son las referencias a métodos?

Una referencia a método es una forma abreviada de lambda que delega en un método existente. Cuando una lambda solo llamaría a un método, una referencia a método resulta más limpia y legible.

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("Alice", "Bob", "Carol");

// Lambda:
names.forEach(s -> System.out.println(s));

// Equivalent method reference:
names.forEach(System.out::println);

Sintaxis de una referencia a método estático

Una referencia a método estático tiene la forma ClassName::staticMethodName. Puede utilizarse siempre que una interfaz funcional espere un método con la misma firma.

import java.util.stream.*;

// Integer.parseInt(String) matches Function<String, Integer>
List<String> strs = List.of("1","2","3","4","5");
List<Integer> nums = strs.stream()
    .map(Integer::parseInt)  // replaces s -> Integer.parseInt(s)
    .collect(Collectors.toList());
System.out.println(nums); // [1, 2, 3, 4, 5]

Math.abs como referencia a método

Los métodos estáticos de clases de utilidades como Math pueden referenciarse directamente:

import java.util.*;
import java.util.stream.*;

List<Integer> values = List.of(-3, 5, -1, 8, -4);
List<Integer> abs = values.stream()
    .map(Math::abs)  // replaces v -> Math.abs(v)
    .collect(Collectors.toList());
System.out.println(abs); // [3, 5, 1, 8, 4]

Referencia a método estático con Predicate

Los métodos estáticos cuyo valor de retorno es booleano pueden utilizarse como Predicate:

import java.util.stream.*;

// String.isEmpty() is an instance method, but we can use a static helper
// Objects.isNull matches Predicate<Object>
List<String> mixed = Arrays.asList("hello", null, "world", null);
long nullCount = mixed.stream()
    .filter(Objects::isNull)
    .count();
System.out.println(nullCount); // 2

long nonNull = mixed.stream()
    .filter(Objects::nonNull)
    .count();
System.out.println(nonNull); // 2

Referencia estática de Comparator

También pueden referenciarse los métodos estáticos que coinciden con Comparator:

import java.util.*;
import java.util.stream.*;

List<String> words = List.of("banana", "apple", "cherry");

// String.CASE_INSENSITIVE_ORDER is a Comparator
List<String> sorted = words.stream()
    .sorted(String::compareToIgnoreCase)
    .collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]

Método auxiliar estático personalizado

Definir un método de utilidad estático y referenciarlo directamente:

class Validator {
    static boolean isPositive(int n) { return n > 0; }
    static String toLabel(int n) { return n > 0 ? "POS" : "NEG"; }
}

List<Integer> nums = List.of(-2, 3, -1, 5, 0);

List<Integer> positive = nums.stream()
    .filter(Validator::isPositive)
    .collect(Collectors.toList());
System.out.println(positive); // [3, 5]

List<String> labels = nums.stream()
    .map(Validator::toLabel)
    .collect(Collectors.toList());

BiFunction con un método estático

Los métodos estáticos que reciben dos parámetros pueden coincidir con BiFunction<T,U,R>:

import java.util.function.*;

// Math.max(int,int) → BiFunction... but needs IntBinaryOperator
java.util.function.IntBinaryOperator maxOp = Math::max;
System.out.println(maxOp.applyAsInt(7, 3)); // 7

// String.format as BiFunction? Only works if signature matches:
// Integer.sum(int,int) → IntBinaryOperator
java.util.function.IntBinaryOperator sum = Integer::sum;
System.out.println(sum.applyAsInt(10, 20)); // 30

Ordenar con Comparator.comparing + referencia estática

Combinar Comparator.comparing con referencias a métodos para ordenar de forma clara:

record Person(String name, int age) {}
List<Person> people = List.of(
    new Person("Charlie",30), new Person("Alice",25), new Person("Bob",35)
);

people.stream()
    .sorted(Comparator.comparing(Person::name))
    .forEach(p -> System.out.println(p.name()));
// Alice, Bob, Charlie

Cuándo usar referencias a métodos estáticos

Usar referencias a métodos estáticos cuando:

  • El cuerpo de la lambda es una única llamada a un método estático
  • No es necesario transformar los argumentos
  • La firma del método coincide con la interfaz funcional

Si es necesario transformar argumentos o añadir lógica, utilizar una lambda.

Comparación de legibilidad

Comparación lado a lado de los estilos de lambda y referencia a método:

// Lambda style
Stream.of("1","2","3").map(s -> Integer.parseInt(s));
Stream.of(1,-2,3).filter(n -> n > 0);
Stream.of(-5,2,-1).map(n -> Math.abs(n));

// Method reference style
Stream.of("1","2","3").map(Integer::parseInt);
Stream.of(1,-2,3).filter(Validator::isPositive);
Stream.of(-5,2,-1).map(Math::abs);

Error común: firma incorrecta

Una referencia a método solo funciona si su firma coincide exactamente con el método abstracto de la interfaz funcional. Si los tipos o la cantidad de argumentos difieren, usar una lambda envolvente.

// Math.pow(double, double) needs two args — can't use as Function<Double, Double>
// This won't compile:
// Function<Double, Double> square = Math::pow; // ERROR

// Fix with lambda:
Function<Double, Double> square = n -> Math.pow(n, 2);
System.out.println(square.apply(5.0)); // 25.0

Comprobación rápida

¿Cuál de las siguientes es una referencia a método estático válida que funciona como Predicate<Object>?

Resumen: referencias a métodos estáticos

Puntos clave:

  • Sintaxis: ClassName::staticMethodName
  • Sustituye lambdas que delegan en un único método estático
  • La firma del método debe coincidir con el método abstracto de la interfaz funcional
  • Funciona con Predicate, Function, Consumer, Comparator, etc.
  • Usar lambdas cuando sea necesario transformar argumentos o añadir lógica

Preguntas frecuentes

¿La lección «Referencias a métodos estáticos» es gratis?

Sí — el texto completo de «Referencias a métodos estáticos» 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 «Referencias a métodos estáticos»?

Sustituya lambdas que llaman a métodos estáticos por referencias ClassName::methodName. 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 «Referencias a métodos estáticos»?

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

  1. Referencias a métodos estáticos
  2. Referencias a métodos de instancia específica
  3. Referencias a métodos de instancia arbitraria
  4. Referencias a constructores
← Volver a Java Academy