Il n'est pas encore trop tard? Exemple d'utilisation de toutes les méthodes de l'API Java Stream (opération intermédiaire)

Commencer

Stream API a commencé à partir de Java8, mais quand et quoi utiliser Parfois? Donc, en guise de mémorandum, je me concentrerai cette fois sur le «traitement intermédiaire». Par conséquent, je vais omettre les explications détaillées et publier de plus en plus d'exemples de code.

** (Bien que ce soit écrit comme toutes les méthodes, certaines sont omises. Je suis désolé) **

Cette fois, seul l'exemple d'utilisation du flux utilisant ArrayList est affiché.

Éléments techniques

• Java(8 or later)

Avantages de l'utilisation de l'API Stream

• Meilleure lisibilité (parfois et parfois)
• Vous pouvez écrire du code de manière intuitive.
• Réduit la quantité de code pour le traitement parallèle (non mentionné ici)

Connaissance préalable

• Utilisation de base de l'API Stream
• Utilisation de base de l'expression lambda

Préparation préalable

Book.java

class Book {
    private Integer id;         //Identifiant du magasin
    private String title;       //Titre de livre
    private String author;      //Auteur
    private Integer age;        //Âge cible

    Book(Integer id, String title, String author, Integer age) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.age = age;
    }

    public Integer getId() { return id; }
    public String getTitle() { return title; }
    public String getAuthor() { return author; }
    public Integer getAge() { return age; }

    @Override
    public String toString() {
        return "[id: " + getId() + ", title: " + getTitle() + ", author: " + getAuthor() + ", age: " + getAge() + "]";
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        List<Book> bookList = Arrays.asList(
                  new Book(1, "book1", "author1", 20)
                , new Book(2, "book2", "author2", 12)
                , new Book(3, "book3", "author3", 6));


//Décrivez le traitement utilisé ci-dessous ici.

Introduction de chaque méthode

filtre - filtre par condition

Main.java

bookList.stream()
        .filter(e -> e.getAge() == 12)  //âge=Extraire seulement 12
        .forEach(System.out::println);

//Résultats attendus
[id: 2, title: book2, author: author2, age: 12]

map - Effectuer un traitement tel que la conversion de type (conversion 1: 1)

Main.java

bookList.stream()
        // [Titre:Auteur]Convertir en forme de
        .map(e -> "[" + e.getTitle() + " : " + e.getAuthor() + "]")
        .forEach(System.out::print);

//Résultats attendus
[book1 : author1][book2 : author2][book3 : author3]

Effectue des traitements tels que la conversion de type flatMap (conversion 1: N, N est un nombre naturel)

Main.java

bookList.stream()
        .flatMap(e -> Stream.of(e.getId(), e.getTitle())) //Extraire l'identifiant et le titre
        .forEach(System.out::println);

//Résultats attendus
1
book1
2
book2
3
book3

distinct - supprimer les doublons

Main.java

List<Integer> distinctList = Arrays.asList(1, 1, 2, 2, 2, 3, 4, 4, 5, 4, 6);

distinctList.stream()
            .distinct() //Suppression des doublons
            .forEach(System.out::println);

//Résultats attendus
1
2
3
4
5
6

trié --Trier (vous pouvez trier différemment en ajoutant un argument à trié)

Main.java

List<Integer> sortList = Arrays.asList(4, 2, 5, 10, 1);

sortList.stream()
        .sorted()      //Trier par ordre naturel
        .forEach(System.out::println);

//Résultats attendus
1
2
4
5
10

peek - Traitement intermédiaire qui ne modifie pas le flux.

Main.java

bookList.stream()
        .peek(System.out::println) //Déconnexion, etc.
        .filter(e -> e.getAge() < 16)
        .forEach(System.out::println);

//Résultats attendus
[id: 1, title: book1, author: author1, age: 20] // peek()Sortie par
[id: 2, title: book2, author: author2, age: 12] // peek()Sortie par
[id: 2, title: book2, author: author2, age: 12]
[id: 3, title: book3, author: author3, age: 6]  // peek()Sortie par
[id: 3, title: book3, author: author3, age: 6]

limit-Afficher jusqu'à (argument) éléments.

Main.java

bookList.stream()
        .limit(2)   //Serrez à deux
        .forEach(System.out::println);

//Résultats attendus
[id: 1, title: book1, author: author1, age: 20]
[id: 2, title: book2, author: author2, age: 12]

skip-Skip (argument) éléments et afficher le reste.

Main.java

bookList.stream()
        .skip(1)   //Passer un
        .forEach(System.out::println);

//Résultats attendus
[id: 2, title: book2, author: author2, age: 12]
[id: 3, title: book3, author: author3, age: 6]

Résumé

• Étant donné que les données sont du texte, il n'y a pas de signification particulière aux données ou comment les conserver.
• Il existe de nombreux cas où la lisibilité est améliorée en utilisant l'API Stream, vous devez donc l'utiliser dans de tels cas.
• Bien que j'aie dit que j'ai essayé toutes les méthodes, j'ai omis les méthodes suivantes qui sont de types différents. Pardon.
  • mapToInt()
  • mapToLong()
  • mapToDouble()
  • flatMapToInt()
  • flatMapToLong()
  • flatMapToDouble()