Schémas fonctionnels avec Groovy
Appliquez les fermetures et les méthodes de collection pour mettre en œuvre des schémas de programmation fonctionnelle dans votre code Groovy.
Schémas fonctionnels avec Groovy est une leçon Groovy & Gradle: JVM Automation and Build Engineering gratuite sur CoddyKit. Ceci est la leçon 3 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 Groovy & Gradle: JVM Automation and Build Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Functional Groovy: An Introduction
Welcome to Functional Patterns with Groovy! In this lesson, we'll explore how to write more expressive and maintainable code using a functional style.
Functional programming is a paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. Groovy's closures and enhanced collection methods make it a fantastic language for adopting these patterns.
Why Functional Programming?
Adopting a functional style offers several benefits:
- Cleaner Code: Often more concise and readable.
- Easier Testing: Functions without 'side effects' are predictable.
- Reduced Bugs: Less mutable state means fewer unexpected changes.
- Concurrency: Easier to parallelize operations.
We'll focus on patterns that transform data without altering the original collections.
Iteration vs. Transformation
Before diving into functional transformations, let's look at a common imperative way to process a list using each. While useful for side effects (like printing), it doesn't create new, transformed collections.
Functional patterns, on the other hand, focus on producing new collections from existing ones, leaving the originals untouched.
class Main {
static void main(String[] args) {
List numbers = [1, 2, 3]
print("Original: ")
numbers.each { num ->
print("$num ")
}
println("\nThis doesn't create a new list.")
}
}`collect`: Mapping Data
The collect method is Groovy's equivalent of the map operation. It takes a closure and applies it to each element in a collection, returning a new list with the transformed elements.
This is a core functional pattern for data transformation.
class Main {
static void main(String[] args) {
List numbers = [1, 2, 3, 4]
List doubledNumbers = numbers.collect { it * 2 }
println("Original: $numbers")
println("Doubled: $doubledNumbers")
}
}`findAll`: Filtering Data
The findAll method (similar to filter) selects elements from a collection that satisfy a given condition. The closure you provide should return true or false for each element.
It also returns a new list containing only the elements that passed the filter.
class Main {
static void main(String[] args) {
List numbers = [1, 2, 3, 4, 5, 6]
List evenNumbers = numbers.findAll { it % 2 == 0 }
println("Original: $numbers")
println("Evens: $evenNumbers")
}
}`inject`: Reducing Collections
The inject method (also known as reduce or fold) is used to combine all elements in a collection into a single result. You provide an initial value and a closure that takes two arguments: the accumulator and the current element.
It's powerful for summing, concatenating, or performing complex aggregations.
class Main {
static void main(String[] args) {
List numbers = [1, 2, 3, 4]
// Calculate sum starting with 0
def sum = numbers.inject(0) { total, num -> total + num }
println("Numbers: $numbers")
println("Sum: $sum")
}
}Chaining Functional Calls
One of the great advantages of functional patterns is the ability to chain operations. Since methods like collect and findAll return new collections, you can call another collection method directly on the result.
This creates readable data processing pipelines.
class Main {
static void main(String[] args) {
List products = [
[name: "Laptop", price: 1200, stock: 5],
[name: "Mouse", price: 25, stock: 20],
[name: "Keyboard", price: 75, stock: 0]
]
def expensiveAvailableProductNames = products
.findAll { it.stock > 0 && it.price > 50 }
.collect { it.name.toUpperCase() }
println("Products: $products")
println("Expensive Available: $expensiveAvailableProductNames")
}
}Custom Sorting with `sort`
Groovy's sort method is very flexible. When given a closure, it uses that closure to determine the sorting order. The closure should take two arguments (a and b) and return a negative, zero, or positive integer if a is less than, equal to, or greater than b, respectively.
class Main {
static void main(String[] args) {
List words = ["apple", "banana", "cat", "dog"]
// Sort by length, then alphabetically if lengths are equal
List sortedWords = words.sort { a, b ->
def lengthComparison = a.length() <=> b.length()
return lengthComparison != 0 ? lengthComparison : a <=> b
}
println("Original: $words")
println("Sorted: $sortedWords")
}
}`groupBy`: Categorizing Data
The groupBy method is excellent for organizing data into categories. It takes a closure that determines the key for each element. The result is a Map where keys are the values returned by the closure, and values are lists of elements belonging to that category.
class Main {
static void main(String[] args) {
List people = [
[name: "Alice", age: 30, city: "NY"],
[name: "Bob", age: 25, city: "LA"],
[name: "Charlie", age: 30, city: "NY"],
[name: "David", age: 35, city: "LA"]
]
def peopleByCity = people.groupBy { it.city }
println("People: $people")
println("Grouped by City: $peopleByCity")
}
}Functional Flow Challenge
Test your understanding of chaining functional operations!
Recap: Functional Groovy
Great job! You've explored how to apply functional programming patterns in Groovy:
collect: Transforms elements into a new list.findAll: Filters elements based on a condition.inject: Reduces a collection to a single value.sort: Customizes sorting with closures.groupBy: Categorizes elements into a map.
By chaining these methods, you can build powerful, readable, and maintainable data processing pipelines. Keep practicing to master this elegant style!
Apprends Groovy avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 12
- Leçons
- 48
Questions Fréquemment Posées
La leçon « Schémas fonctionnels avec Groovy » est-elle gratuite ?
Oui — le texte complet de « Schémas fonctionnels avec Groovy » 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 Groovy & Gradle: JVM Automation and Build Engineering, passe à CoddyKit PRO. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Schémas fonctionnels avec Groovy » ?
Appliquez les fermetures et les méthodes de collection pour mettre en œuvre des schémas de programmation fonctionnelle dans votre code Groovy. Tu pratiques Groovy & Gradle: JVM Automation and Build Engineering 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 Groovy & Gradle: JVM Automation and Build Engineering ?
Aucune expérience préalable n'est requise. Groovy & Gradle: JVM Automation and Build Engineering 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 3 sur 4.
Combien de temps prend la leçon « Schémas fonctionnels avec Groovy » ?
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 Groovy & Gradle: JVM Automation and Build Engineering ?
Oui. Chaque leçon Groovy & Gradle: JVM Automation and Build Engineering 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
- Améliorations des collections Groovy
- Comprendre les fermetures Groovy
- Schémas fonctionnels avec Groovy
- Curryfication et composition de fermetures