Introduction
L'API Stream Java offre un moyen puissant et polyvalent de travailler avec des collections de données. Dans ce tutoriel, nous allons explorer comment tirer parti de l'API Stream pour filtrer les collections, vous permettant d'extraire efficacement les données dont vous avez besoin. Que vous soyez un débutant en Java ou un développeur expérimenté, ce guide vous dotera des connaissances et des compétences nécessaires pour rationaliser vos tâches de traitement de données.
Introduction à l'API Stream Java
L'API Stream Java est une fonctionnalité puissante introduite dans Java 8 qui vous permet de traiter des collections de données de manière déclarative et fonctionnelle. Les flux (streams) offrent un moyen d'effectuer diverses opérations sur les données, telles que le filtrage, le mappage, le tri et la réduction, sans avoir besoin d'itérer explicitement ou de maintenir un état mutable.
Comprendre les flux (streams)
Un flux (stream) est une séquence d'éléments qui prend en charge diverses opérations pour effectuer des calculs sur ces éléments. Les flux peuvent être créés à partir de diverses sources de données, telles que des collections, des tableaux ou même des ressources d'E/S. Les flux offrent une API fluide qui vous permet de chaîner plusieurs opérations ensemble, rendant votre code plus expressif et plus lisible.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
stream.filter(n -> n % 2 == 0)
.map(n -> n * 2)
.forEach(System.out::println);
Dans l'exemple ci-dessus, nous créons un flux à partir d'une liste d'entiers, filtrons les nombres pairs, les transformons en leurs valeurs doublées, puis affichons les résultats.
Avantages de l'utilisation des flux (streams)
- Programmation déclarative : Les flux vous permettent d'exprimer votre intention de manière plus déclarative, en vous concentrant sur ce que vous voulez obtenir plutôt que sur la façon de l'obtenir.
- Parallélisme : Les flux peuvent être facilement parallélisés, vous permettant de tirer parti des processeurs multi-cœurs et d'améliorer les performances.
- Lenteur (Laziness) : Les flux sont paresseux (lazy), ce qui signifie que les opérations ne sont effectuées que lorsque le résultat final est nécessaire, ce qui peut améliorer l'efficacité.
- API fluide : L'API Stream offre un moyen fluide et expressif de chaîner plusieurs opérations ensemble, rendant votre code plus lisible et plus maintenable.
Explorer les opérations sur les flux (streams)
Les flux offrent un large éventail d'opérations que vous pouvez utiliser pour manipuler vos données. Certaines des opérations les plus courantes incluent :
- Filtrage : Sélectionner des éléments en fonction d'un prédicat donné.
- Mappage : Transformer des éléments à l'aide d'une fonction.
- Tri : Classer les éléments en fonction d'un comparateur.
- Réduction : Combiner des éléments en un seul résultat.
- Collecte : Rassembler les résultats dans une nouvelle structure de données.
Dans les sections suivantes, nous approfondirons l'utilisation spécifique de l'API Stream pour filtrer les collections.
Filtrer des collections avec les flux (streams)
Le filtrage est l'une des opérations les plus courantes effectuées sur les collections à l'aide de l'API Stream Java. Le filtrage vous permet de sélectionner un sous-ensemble d'éléments d'une collection en fonction d'un prédicat donné.
Appliquer des filtres
La méthode filter() est utilisée pour appliquer un filtre à un flux (stream). Cette méthode prend une expression lambda ou une référence de méthode en argument, qui représente la condition de filtrage.
List<String> names = Arrays.asList("John", "Jane", "Bob", "Alice");
Stream<String> filteredNames = names.stream()
.filter(name -> name.startsWith("J"));
filteredNames.forEach(System.out::println);
Dans l'exemple ci-dessus, nous créons un flux à partir d'une liste de noms, puis nous utilisons la méthode filter() pour sélectionner uniquement les noms commençant par la lettre "J".
Chaîner plusieurs filtres
Vous pouvez chaîner plusieurs appels de filter() pour appliquer plusieurs conditions de filtrage à un flux.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Stream<Integer> filteredNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.filter(n -> n > 5);
filteredNumbers.forEach(System.out::println);
Dans cet exemple, nous filtrons d'abord les nombres pour sélectionner uniquement les nombres pairs, puis nous appliquons un deuxième filtre pour sélectionner uniquement les nombres pairs supérieurs à 5.
Combiner des filtres avec d'autres opérations
Le filtrage peut être combiné avec d'autres opérations sur les flux, telles que le mappage, le tri et la réduction, pour créer des transformations de données plus complexes.
List<Person> persons = Arrays.asList(
new Person("John", 30),
new Person("Jane", 25),
new Person("Bob", 35),
new Person("Alice", 28)
);
List<String> youngAdultNames = persons.stream()
.filter(p -> p.getAge() >= 18 && p.getAge() < 30)
.map(Person::getName)
.collect(Collectors.toList());
System.out.println(youngAdultNames);
Dans cet exemple, nous filtrons d'abord la liste d'objets Person pour sélectionner uniquement les jeunes adultes (âgés entre 18 et 30 ans), puis nous mappons la propriété Name de chaque objet Person, et enfin nous collectons les résultats dans une nouvelle liste.
En comprenant le pouvoir du filtrage avec l'API Stream Java, vous pouvez manipuler et traiter efficacement vos collections de données. Dans la section suivante, nous explorerons des exemples pratiques supplémentaires d'application de filtres.
Appliquer des filtres : exemples pratiques
Maintenant que vous avez une bonne compréhension des bases du filtrage avec l'API Stream Java, explorons quelques exemples pratiques pour consolider vos connaissances.
Filtrer des chaînes de caractères
Supposons que vous ayez une liste de chaînes de caractères et que vous souhaitiez sélectionner uniquement celles qui ont une longueur spécifique ou qui commencent par un certain caractère.
List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
// Filter words with length greater than 5 characters
List<String> longWords = words.stream()
.filter(word -> word.length() > 5)
.collect(Collectors.toList());
System.out.println(longWords); // [banana, cherry, elderberry]
// Filter words starting with 'a'
List<String> wordsStartingWithA = words.stream()
.filter(word -> word.startsWith("a"))
.collect(Collectors.toList());
System.out.println(wordsStartingWithA); // [apple, date]
Filtrer des nombres
Vous pouvez également utiliser l'API Stream pour filtrer des données numériques, telles que des entiers ou des nombres à virgule flottante.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// Filter even numbers
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers); // [2, 4, 6, 8, 10]
// Filter numbers greater than 5
List<Integer> numbersGreaterThan5 = numbers.stream()
.filter(n -> n > 5)
.collect(Collectors.toList());
System.out.println(numbersGreaterThan5); // [6, 7, 8, 9, 10]
Filtrer des objets personnalisés
Vous pouvez également appliquer des filtres à des collections d'objets personnalisés, tels que des objets Person.
class Person {
private String name;
private int age;
// Getters, setters, and constructor
}
List<Person> persons = Arrays.asList(
new Person("John", 30),
new Person("Jane", 25),
new Person("Bob", 35),
new Person("Alice", 28)
);
// Filter persons older than 30
List<Person> personsOlderThan30 = persons.stream()
.filter(p -> p.getAge() > 30)
.collect(Collectors.toList());
System.out.println(personsOlderThan30); [ [Person(name=Bob, age=35)]
// Filter persons with names starting with 'J'
List<Person> personsWithNameStartingWithJ = persons.stream()
.filter(p -> p.getName().startsWith("J"))
.collect(Collectors.toList());
System.out.println(personsWithNameStartingWithJ); [ [Person(name=John, age=30), Person(name=Jane, age=25)]
En explorant ces exemples pratiques, vous devriez maintenant mieux comprendre comment utiliser efficacement la méthode filter() pour manipuler vos collections en Java.
Résumé
À la fin de ce tutoriel, vous aurez une bonne compréhension de l'utilisation de l'API Stream Java pour filtrer des collections. Vous apprendrez les diverses méthodes de filtrage disponibles, telles que filter(), distinct() et limit(), et comment les appliquer à vos cas d'utilisation spécifiques. Grâce aux connaissances acquises, vous pourrez écrire un code Java plus efficace et plus facilement maintenable, optimiser vos flux de traitement de données et exploiter pleinement le potentiel de l'API Stream.
