Android Academy · Leçon

Lambdas et fonctions d’ordre supérieur

Transmettez le comportement comme valeur.

Lambdas et fonctions d’ordre supérieur est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Qu’est-ce qu’une lambda ?

Une lambda est une petite fonction que vous pouvez écrire directement, sans lui donner de nom.

Vous l’entourez d’accolades : { x -> x + 1 }. Les lambdas vous permettent de transmettre un comportement comme s’il s’agissait de données.

Vous les avez déjà utilisées avec map et filter.

Stocker une lambda dans une variable

Une lambda est une valeur : vous pouvez donc la stocker dans une variable et l’appeler plus tard.

Appelez-la comme une fonction, en utilisant des parenthèses.

fun main() {
    val square = { x: Int -> x * x }
    println(square(5))
    println(square(3))
}

Le raccourci it

Lorsqu’une lambda possède exactement un paramètre, vous pouvez ne pas le nommer et utiliser it.

Cela permet de garder les lambdas courtes compactes et lisibles.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    val big = nums.filter { it > 2 }
    println(big)
}

Plusieurs paramètres

Une lambda peut accepter plusieurs paramètres, séparés par des virgules avant la flèche.

La dernière expression de la lambda constitue sa valeur de retour.

fun main() {
    val add = { a: Int, b: Int -> a + b }
    println(add(4, 6))
}

Fonctions d’ordre supérieur

Une fonction d’ordre supérieur est une fonction qui accepte une autre fonction comme paramètre ou qui en renvoie une.

Le type de fonction (Int) -> Int signifie « accepte un Int et renvoie un Int ». C’est ainsi que fonctionnent map et filter.

Écrire une fonction d’ordre supérieur

Ici, nous définissons applyTwice, qui accepte une fonction et l’exécute deux fois.

Le paramètre op possède le type (Int) -> Int.

fun applyTwice(x: Int, op: (Int) -> Int): Int {
    return op(op(x))
}

fun main() {
    println(applyTwice(3) { it + 1 })
}

Syntaxe de la lambda finale

Lorsqu’une lambda est le dernier argument, vous pouvez la placer après les parenthèses.

C’est pourquoi list.filter { ... } est si lisible. Les deux formes ci-dessous sont équivalentes.

fun main() {
    val nums = listOf(1, 2, 3)
    println(nums.map({ it * 2 }))
    println(nums.map { it * 2 })
}

Transmettre des fonctions nommées

Vous pouvez transmettre une fonction nommée existante là où une lambda est attendue en utilisant ::, appelé une référence de fonction.

Cela évite de réécrire la logique sous forme de lambda.

fun isOdd(n: Int) = n % 2 == 1

fun main() {
    val nums = listOf(1, 2, 3, 4)
    println(nums.filter(::isOdd))
}

Renvoyer une fonction

Une fonction d’ordre supérieur peut également renvoyer une fonction. Ici, multiplier construit une lambda personnalisée pour effectuer des multiplications.

Il s’agit d’une forme simple de configuration.

fun multiplier(factor: Int): (Int) -> Int {
    return { it * factor }
}

fun main() {
    val triple = multiplier(3)
    println(triple(5))
}

Les lambdas capturent les variables

Une lambda peut lire des variables de la portée environnante. On parle alors de fermeture.

Ici, la lambda mémorise bonus, même après avoir été transmise ailleurs.

fun main() {
    val bonus = 10
    val nums = listOf(1, 2, 3)
    println(nums.map { it + bonus })
}

Pourquoi les lambdas sont importantes sous Android

Sous Android, les lambdas permettent d’exprimer clairement les fonctions de rappel. Un écouteur de clic sur un bouton est simplement une lambda que vous transmettez au cadriciel.

Par exemple : button.setOnClickListener { showMenu() } exécute votre code lorsque l’utilisateur appuie sur le bouton.

Vérification rapide

Vérifiez votre compréhension des lambdas et des fonctions d’ordre supérieur.

Récapitulatif

Les lambdas sont des fonctions anonymes écrites directement entre accolades et utilisent it pour un paramètre unique.

Les fonctions d’ordre supérieur acceptent ou renvoient des fonctions, ce qui permet de créer des fonctions de rappel claires et des opérations réutilisables comme map et filter.

Questions Fréquemment Posées

La leçon « Lambdas et fonctions d’ordre supérieur » est-elle gratuite ?

Oui — le texte complet de « Lambdas et fonctions d’ordre supérieur » 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 Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Lambdas et fonctions d’ordre supérieur » ?

Transmettez le comportement comme valeur. Tu pratiques Android 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 Android Academy ?

Aucune expérience préalable n'est requise. Android 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 4 sur 4.

Combien de temps prend la leçon « Lambdas et fonctions d’ordre supérieur » ?

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 Android Academy ?

Oui. Chaque leçon Android 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

← Retour à Android Academy