Chapitre 1 : Installation et exécution de Kotlin

Recette 1.1 : Exécuter Kotlin sans compilateur local
Recette 1.2 Installation de Kotlin sur votre ordinateur local
Recette 1.3 Compilation et exécution de Kotlin en ligne de commande
Recette 1.4 Utilisation du REPL Kotlin
Recette 1.5 Exécution de scripts Kotlin
Recette 1.6 : Création d’applications autonomes avec GraalVM
Recette 1.7 : Ajout du plugin Kotlin à Gradle (syntaxe Groovy)
Recette 1.8 : Ajout du plugin Kotlin à Gradle (syntaxe Kotlin)
Recette 1.9 Création de projets Kotlin avec Gradle
Recette 1.10 Utilisation de Maven avec Kotlin

Chapitre 2 : Les bases de Kotlin

Recette 2.1 : Utilisation des types nullables en Kotlin
Recette 2.2 : Ajout d’indicateurs de tolérance aux valeurs nulles en Java
Recette 2.3 Duplication de méthode pour Java
Recette 2.4 Conversion explicite des types
Recette 2.5 Sortie vers une base différente
Recette 2.6 Élever les nombres à des puissances
Recette 2.7 Utilisation des opérateurs de décalage de bits
Recette 2.8 Utilisation des opérateurs booléens bit à bit
Recette 2.9 Création d'une instance de paire

Chapitre 3 : Programmation orientée objet en Kotlin

Recette 3.1 Comprendre la différence entre Const et Val
Recette 3.2 Création de getters et setters personnalisés
Recette 3.3 Définition des classes de données
Recette 3.4 Techniques d'attributs de support
Recette 3.5 Duplication de l'opérateur
Recette 3.6 Utilisation de lateinit pour une initialisation ultérieure
Recette 3.7 : Utilisation de la conversion de type sécurisée, de l’égalité de référence et d’Elvis pour redéfinir l’égalité
Recette 3.8 Création d'un singleton
Recette 3.9 : Un tapage pour rien

Chapitre 4 Programmation fonctionnelle

Recette 4.1 Utilisation des pliages dans les algorithmes
Recette 4.2 : Graisser avec la fonction de réduction
Recette 4.3 Application de la récursivité terminale

Collection du chapitre 5

Recette 5.1 Gestion des tableaux
Recette 5.2 Créer une collection
Recette 5.3 Création d'une vue en lecture seule à partir d'une collection
Recette 5.4 Création d'une carte à partir d'une collection
Recette 5.5 : Renvoi d’une valeur par défaut si une collection est vide
Recette 5.6 : Limitation des valeurs à une plage donnée
Traitement des collections de recettes 5.7 avec Windows
Recette 5.8 Décomposition des structures de listes
Recette 5.9 Tri par plusieurs attributs
Recette 5.10 Définition d'un itérateur personnalisé
Filtrage des collections par type de recette 5.11
Recette 5.12 Créer une gamme sous forme de séquence

Séquence du chapitre 6

Recette 6.1 Utilisation de séquences différées
Recette 6.2 Création d'une séquence
Recette 6.3 Gestion des séquences infinies
Recette 6.4 Rendements en séquence

Chapitre 7 Fonctions du domaine

Recette 7.1 Initialisation d'un objet après sa création avec apply
Recette 7.2 À utiliser également en cas d'effets secondaires
Recette 7.3 Utilisation de la fonction let et de l'opérateur Elvis
Recette 7.4 Utilisation de let comme variable temporaire

Chapitre 8 : Délégués Kotlin

Recette 8.1 : Mise en œuvre de la composition à l’aide de délégués
Recette 8.2 Utiliser des délégués paresseux
Recette 8.3 Empêcher les valeurs d'être nulles
Recette 8.4 Utilisation des délégués observables et vetoables
Recette 8.5 : Fournir une carte en tant que délégué
Recette 8.6 Création d'un délégué personnalisé

Test du chapitre 9

Recette 9.1 Configuration du cycle de vie de la classe de test
Recette 9.2 Utilisation des classes de données dans les tests
Recette 9.3 Utilisation des fonctions auxiliaires avec arguments par défaut
Recette 9.4 Répétition des tests JUnit 5 sur plusieurs jeux de données
Recette 9.5 Utilisation de la classe de données dans les tests paramétrés

Chapitre 10 Entrée/Sortie

Gestion des ressources avec Recipe 10.1
Enregistrement de la recette 10.2 dans le fichier

Chapitre 11 Autres fonctionnalités de Kotlin

Recette 11.1 : Trouver la version Kotlin
Recette 11.2 Exécution répétée de Lambda
Recette 11.3 : Forcer le parfait quand
Recette 11.4 Utilisation de la fonction de remplacement avec des expressions régulières
Recette 11.5 Conversion vers et depuis une chaîne binaire
Recette 11.6 Création d'une classe exécutable
Recette 11.7 Mesure du temps écoulé
Recette 11.8 Début du fil
Recette 11.9 : Forcer la complétion avec TODO
Recette 11.10 Comprendre le comportement aléatoire
Recette 11.11 Utilisation de caractères spéciaux dans les noms de fonctions
Recette 11.12 : Notifier Java des exceptions

Chapitre 12 : Framework Spring

Ouverture d'un cours sur les haricots à gestion printanière pour l'extension de la recette 12.1
Recette 12.2 : Implémentation de la persistance avec les classes de données Kotlin
Recette 12.3 Injection de dépendances

Chapitre 13 : Coroutines et concurrence structurée

Recette 13.1 Choisir un générateur de coroutines
Recette 13.2 : Remplacer async/await par withContext
Recette 13.3 Utilisation du répartiteur
Recette 13.4 : Exécution de coroutines dans un pool de threads Java
Recette 13.5 : Annulation d’une coroutine
Recette 13.6 Débogage des coroutines

[Structure de ce livre]

Ce livre contient de nombreuses recettes, chacune indépendante mais la plupart liées à d'autres recettes.
L'ordre dans lequel vous lirez le livre est à votre discrétion, mais les sujets abordés dans chaque chapitre sont les suivants :

- Le chapitre 1, « Installation et exécution de Kotlin », couvre les bases de l'installation et de l'exécution de Kotlin, notamment comment utiliser le REPL, comment utiliser des outils de construction comme Maven et Gradle, et comment utiliser le générateur d'images natif inclus dans Graal.

- Le chapitre 2, « Notions de base de Kotlin », aborde certaines des fonctionnalités de base de Kotlin, telles que les types nullables, la surcharge d'opérateurs et la conversion de type, avant de traiter des questions plus complexes, telles que les opérateurs de décalage bit à bit ou la manière d'utiliser la fonction d'extension to de la classe Pair.

- Le chapitre 3, « Programmation orientée objet Kotlin », se concentre sur les fonctionnalités orientées objet de Kotlin que les développeurs venant d'autres langages pourraient trouver surprenantes ou uniques.
Ce chapitre explique comment utiliser le mot-clé const, comment Kotlin gère les propriétés sous-jacentes, l'initialisation paresseuse et la redoutable classe Nothing, qui ne manquera pas de déconcerter les développeurs Java existants.

- Le chapitre 4, « Programmation fonctionnelle », ne contient que quelques exemples utilisant des fonctionnalités fonctionnelles qui nécessitent une explication de ces fonctionnalités.
Les concepts de programmation fonctionnelle sont abordés tout au long de ce livre, notamment lors de la discussion des collections, des séquences et des coroutines, mais ce chapitre décrit quelques techniques fonctionnelles que vous pourriez trouver inhabituelles ou particulièrement intéressantes.

- Le chapitre 5, « Collections », traite principalement de méthodes qui ne sont pas intuitives à utiliser, telles que les tableaux et les collections, la décomposition des collections, le tri à l'aide de plusieurs propriétés, l'utilisation de fenêtres dans les collections et la création de séquences.

- Le chapitre 6, « Séquence », montre comment Kotlin gère les éléments de séquence en utilisant l'évaluation paresseuse, de la même manière que Java utilise les flux.
Les recettes de ce chapitre traitent de la création de séquences, de la génération de résultats à partir de séquences et de l'utilisation de séquences infinies.

- Le chapitre 7, « Fonctions de portée », aborde un autre sujet unique en Kotlin : les fonctions qui exécutent des blocs de code dans un contexte d’objet.
Les fonctions de Kotlin comme let, apply, etc. sont également très utiles.
Ce chapitre explique en détail comment et pourquoi utiliser ces fonctions.

- Le chapitre 8, « Délégués Kotlin », explique les fonctionnalités pratiques de Kotlin, notamment comment implémenter des délégués.
Les délégués utilisent la composition plutôt que l'héritage, et plusieurs délégués, tels que lazy, observable et vetoable, sont inclus dans la bibliothèque de base Kotlin.

- Le chapitre 9, « Tests », aborde le sujet important des tests, avec un accent particulier sur JUnit 5.
La version actuelle de JUnit est conçue pour fonctionner aussi bien avec les applications Kotlin classiques qu'avec les applications Kotlin utilisant le framework Spring.
Ce chapitre aborde plusieurs approches qui facilitent l'écriture et l'exécution des tests.

- Le chapitre 10, « Entrée/Sortie », aborde deux recettes spécifiques liées à la gestion des ressources.
Ce chapitre traite de la gestion des entrées/sorties de fichiers à l'aide de la fonction use, qui a de nombreuses applications dans divers contextes.

- Le chapitre 11, « Autres fonctionnalités de Kotlin », aborde des sujets qui ne peuvent pas être facilement inclus dans une autre catégorie.
Les sujets abordés incluent comment obtenir la version actuelle de Kotlin, comment forcer une instruction when même si elle ne renvoie pas de valeur, et comment utiliser la fonction replace avec des expressions régulières.
De plus, la fonction TODO et la classe Random sont expliquées.
Vous apprendrez également à intégrer les fonctions Kotlin à la gestion des exceptions Java.

- Le chapitre 12, « Spring Framework », couvre le framework Spring ainsi que Spring Boot, qui est très compatible avec Kotlin.
Ce chapitre contient plusieurs exemples qui montrent comment utiliser les classes Kotlin en tant que beans gérés par Spring, comment implémenter la persistance JPA et comment injecter des dépendances en cas de besoin.

- Le chapitre 13, « Coroutines et concurrence structurée », aborde le sujet des coroutines, l'une des fonctionnalités les plus populaires de Kotlin et la base de la programmation concurrente et parallèle dans le langage Kotlin.
Les recettes de ce chapitre couvrent les notions de base telles que les constructeurs et les répartiteurs, comment annuler et déboguer les coroutines, et comment exécuter des coroutines sur un pool de threads Java personnalisé.


[À qui ce livre est destiné]
Les débutants qui apprennent Kotlin pour la première fois mais qui souhaitent l'apprendre de manière plus pratique, et les utilisateurs de Kotlin qui ont déjà commencé mais qui souhaitent apprendre des techniques avancées.
Il est particulièrement utile pour les développeurs qui possèdent une compréhension de base de la programmation orientée objet en Java ou dans d'autres langages basés sur la JVM.



[Note de l'auteur]

Bienvenue dans le livre de recettes Kotlin.
L'objectif principal de ce livre n'est pas seulement d'enseigner la syntaxe et la sémantique de Kotlin, mais aussi de montrer quand et pourquoi utiliser des fonctionnalités spécifiques de Kotlin.
Pour atteindre cet objectif, il n'est pas nécessaire de couvrir en détail toute la syntaxe et les bibliothèques de Kotlin.
Cependant, de nombreuses recettes basées sur les principes de base ont été ajoutées, rendant le livre facile à comprendre même pour les débutants en Kotlin.

JetBrains déploie des efforts considérables pour encourager la communauté Kotlin à adopter le développement JavaScript natif et multiplateforme.
Cependant, étant donné que le développement multiplateforme, natif et JavaScript avec Kotlin est soit en version bêta, soit très peu adopté, j'ai finalement décidé de ne pas inclure le développement multiplateforme, natif et JavaScript dans la recette.
Par conséquent, ce livre se concentre exclusivement sur Kotlin pour la JVM.

Vous trouverez l'intégralité du code de ce livre sur le dépôt GitHub : https://github.com/kousen/kotlin-cookbook.
Le code inclut un wrapper Gradle (ainsi qu'un fichier de construction écrit en Kotlin DSL) et réussit tous les tests.

Tous les exemples de code de ce livre ont été compilés et testés sur des versions LTS (Long Term Support) de Java facilement disponibles, à savoir Java 8 et Java 11.
Bien que Java 8 soit techniquement obsolète, il reste largement utilisé dans l'industrie, et des exemples de code sont toujours disponibles.
Au moment de la rédaction de ce livre, la dernière version de Kotlin était la 1.3.50, la version 1.3.60 étant en cours de développement.
Tout le code fonctionnera sur les deux versions, et le dépôt GitHub sera mis à jour en continu avec les dernières versions de Kotlin.

Les livres de recettes comme celui-ci s'attachent à être aussi complets que possible sur Kotlin, plutôt que de se concentrer sur les techniques ou la grammaire de Kotlin.
Cela a l'avantage de permettre à toutes les recettes de ce livre d'utiliser pleinement les fonctionnalités de Kotlin, mais aussi l'inconvénient de ne pas consacrer beaucoup de temps à expliquer les bases des fonctionnalités de Kotlin utilisées.
Même si vous ne savez pas comment créer des collections, utiliser des tableaux ou concevoir des classes, ne vous inquiétez pas, chaque chapitre comprend un résumé de leur utilisation de base.
Ce livre aborde également la mise en œuvre de fonctions dans les bibliothèques Kotlin.
Cela montre aux développeurs comment ils utilisent réellement le langage et pourquoi ils l'ont implémenté de cette façon.


[Note du traducteur]
En tant que programmeur, vous vous intéressez toujours aux nouveaux langages de programmation.
J'aime aussi essayer de nouveaux langages de programmation, c'est ainsi que j'ai découvert Kotlin vers 2013, lorsque j'ai appris que JetBrains l'utilisait en production.
À l'époque, j'ai essayé de suivre le tutoriel officiel de Kotlin, mais j'ai été très déçu car il ne présentait aucune fonctionnalité unique par rapport à Groovy ou Scala. J'ai alors écarté Kotlin, le considérant comme un langage purement commercial, et je ne m'y suis plus jamais intéressé. Je pensais ne plus jamais y toucher.

Cependant, l'intérêt du public pour Kotlin a atteint son apogée lorsque l'équipe Android a désigné Kotlin comme langage de développement officiel pour Android lors de la conférence Google I/O en 2017.
De plus, j'avais initialement pris pour un simple effet de manche Eric Meyer, que je respecte pourtant, lorsqu'il avait déclaré apprécier Kotlin lors d'une conférence en 2017. Cependant, Eric Meyer a continué à manifester son attachement à Kotlin en publiant du code et des opinions sur Twitter, et mon indifférence s'est donc progressivement transformée en intérêt.

Après avoir examiné Kotlin 1.2 en 2018, j'ai constaté qu'il y avait eu de nombreuses améliorations et que sa compatibilité avec Java était également excellente. Je me suis donc dit que si je devais réaliser un projet basé sur la JVM à l'avenir, je ne choisirais plus jamais Java.
Aujourd'hui, Kotlin ne se limite plus au développement mobile, mais cherche à s'imposer dans tous les domaines du développement, notamment côté serveur, JavaScript, le développement natif, l'analyse de données et l'apprentissage automatique. Vous trouverez des informations à ce sujet dans la documentation officielle de Kotlin.

Parlons plus en détail du Kotlin côté serveur. Spring, le framework le plus populaire au monde, a officiellement désigné Kotlin comme un langage pris en charge depuis la version 5.0, et Gradle, l'outil d'automatisation de la construction le plus populaire pour la JVM, a également commencé à prendre en charge le DSL Kotlin à partir de la version 5.0.
De cette manière, Kotlin étend progressivement son territoire et je crois qu'il deviendra un langage prometteur à l'avenir.

Bien que ce livre se concentre sur le Kotlin côté serveur parmi les nombreuses applications de Kotlin, il constitue assurément un bon ouvrage pour acquérir les connaissances de base qui vous permettront de progresser dans ce domaine.
Pour les développeurs Java déjà en poste, ce livre leur permet d'apprendre rapidement les notions dont ils ont besoin, contrairement aux nombreux ouvrages de référence disponibles.
De plus, même les débutants en Kotlin peuvent facilement installer le compilateur Kotlin en suivant le livre et progresser étape par étape vers des sujets plus difficiles.

J'utilise actuellement Kotlin Spring dans mon entreprise actuelle, et j'ai eu pas mal de mal à configurer le projet la première fois.
Ce livre contient également des recettes expliquant « Comment construire un projet Spring avec Kotlin », et j'ai été très déçu que sa traduction n'ait pas été réalisée plus tôt, car j'aurais pu éviter les difficultés rencontrées lors de la construction du projet.

J'ai fait de mon mieux, mais il peut y avoir quelques lacunes.
Néanmoins, j'espère que les lecteurs pourront apprendre Kotlin aisément, sans avoir à se soucier de la traduction.