0Pricing
Java Academy · Leçon

Références vers des méthodes statiques

Remplacez les lambdas qui appellent des méthodes statiques par des références ClassName::methodName.

Références vers des méthodes statiques est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Que sont les références de méthodes ?

Une référence de méthode est une lambda abrégée qui délègue l’appel à une méthode existante. Lorsqu’une lambda se contente d’appeler une seule méthode, une référence de méthode est plus claire et plus lisible.

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

Syntaxe d’une référence vers une méthode statique

Une référence vers une méthode statique prend la forme ClassName::staticMethodName. Elle peut être utilisée partout où une interface fonctionnelle attend une méthode ayant la même signature.

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 comme référence de méthode

Les méthodes statiques de classes utilitaires comme Math peuvent être référencées directement :

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]

Référence vers une méthode statique avec un prédicat

Les méthodes statiques qui renvoient une valeur booléenne peuvent servir de 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

Référence statique de Comparator

Les méthodes statiques compatibles avec Comparator peuvent également être référencées :

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éthode utilitaire statique personnalisée

Définissez une méthode utilitaire statique et référencez-la directement :

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 avec une méthode statique

Les méthodes statiques qui prennent deux paramètres peuvent correspondre à 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

Trier avec Comparator.comparing et une référence statique

Combinez Comparator.comparing avec des références de méthodes pour obtenir un tri clair :

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

Quand utiliser les références vers des méthodes statiques

Utilisez les références vers des méthodes statiques lorsque :

  • Le corps de la lambda est un unique appel de méthode statique
  • Aucune transformation des arguments n’est nécessaire
  • La signature de la méthode correspond à celle de l’interface fonctionnelle

Si vous devez transformer les arguments ou ajouter une logique, utilisez plutôt une lambda.

Comparaison de lisibilité

Comparaison côte à côte des styles lambda et référence de méthode :

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

Piège courant : signature incorrecte

Une référence de méthode ne fonctionne que si sa signature correspond exactement à la méthode abstraite de l’interface fonctionnelle. Si les types ou le nombre d’arguments diffèrent, utilisez plutôt une lambda intermédiaire.

// 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

Vérification rapide

Laquelle des propositions suivantes est une référence vers une méthode statique valide pouvant être utilisée comme Predicate<Object> ?

Récapitulatif : références vers des méthodes statiques

Points essentiels :

  • Syntaxe : ClassName::staticMethodName
  • Remplace les lambdas qui délèguent l’appel à une seule méthode statique
  • La signature de la méthode doit correspondre à la méthode abstraite de l’interface fonctionnelle
  • Fonctionne avec les prédicats, Function, les consommateurs, Comparator, etc.
  • Utilisez des lambdas lorsqu’une transformation des arguments ou une logique supplémentaire est nécessaire

Questions Fréquemment Posées

La leçon « Références vers des méthodes statiques » est-elle gratuite ?

Oui — le texte complet de « Références vers des méthodes statiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Références vers des méthodes statiques » ?

Remplacez les lambdas qui appellent des méthodes statiques par des références ClassName::methodName. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Références vers des méthodes statiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Références vers des méthodes statiques
  2. Références vers des méthodes d’instance précises
  3. Références vers des méthodes d’instance arbitraires
  4. Références vers des constructeurs
← Retour à Java Academy