TOC

Opérations sur les chaînes avec les flux Java

Opérations sur les chaînes avec les flux Java

1. Vue d'ensemble

Java 8 a introduit une nouvelle APIStream qui nous permet de traiter les données de manière déclarative.

Dans cet article rapide, nous allons apprendre à utiliser l'APIStream pour diviser unString séparé par des virgules en une liste deStrings et comment joindre un tableauString en unString séparé par des virgules.

Nous verrons également comment convertir un tableau de chaînes en mappage à l'aide de l'APIStream.

Presque tout le temps, nous sommes confrontés à des situations où nous devons itérer certainsJava Collections et filtrer lesCollection en fonction d'une logique de filtrage. Dans une approche traditionnelle pour ce type de situation, nous utilisions beaucoup de boucles et d'opérations if-else pour obtenir le résultat souhaité.

Si vous voulez en savoir plus sur l'APIStream, cochezthis article.

2. Joindre des chaînes avec l'APIStream

Utilisons l'APIStream pour créer une fonction qui joindrait un tableauString dans unString séparé par des virgules: 

public static String join(String[] arrayOfString){
    return Arrays.asList(arrayOfString)
      .stream()
      //.map(...)
      .collect(Collectors.joining(","));
}

Points à noter ici:

  • La fonctionstream() convertit toutCollection en un flux de données

  • La fonctionmap() est utilisée pour traiter les données

  • Il existe également une autre fonction, nomméefilter(), où nous pouvons inclure des critères de filtrage

Il peut y avoir des scénarios, où nous pouvons vouloir joindre unString avec un préfixe et un suffixe fixes. Avec l'APIStream, nous pouvons le faire de la manière suivante: 

public static String joinWithPrefixPostfix(String[] arrayOfString){
    return Arrays.asList(arrayOfString)
      .stream()
      //.map(...)
      .collect(Collectors.joining(",","[","]"));
}

Comme nous pouvons le voir dans la méthodeCollectors.joining(), nous déclarons notre préfixe comme‘[‘ et postfix comme‘]'; par conséquent, lesString générés seront créés avec le format[…..] déclaré.

3. Fractionnement deStrings avec l'APIStream

Maintenant, créons une fonction, qui diviserait unString séparé par des virgules en une liste deString à l'aide de l'APIStream: 

public static List split(String str){
    return Stream.of(str.split(","))
      .map (elem -> new String(elem))
      .collect(Collectors.toList());
}

Il est également possible de convertir directement unString en une listeCharacter à l'aide de l'APIStream: 

public static List splitToListOfChar(String str) {
    return str.chars()
      .mapToObj(item -> (char) item)
      .collect(Collectors.toList());
}

Un fait intéressant à noter ici est que la méthodechars() convertit lesString en un flux deInteger où chaque valeurInteger désigne la valeurASCII de chacun et chaque séquenceChar. C’est pourquoi nous devons convertir explicitement l’objet mappeur dans la méthodemapToObj().

4. String array versMap withStream API

Nous pouvons également convertir un tableauString en mappage en utilisantsplit andCollectors.toMap, à condition que chaque élément du tableau contienne une entité clé-valeur concaténée par un séparateur: 

public static Map arrayToMap(String[] arrayOfString) {
    return Arrays.asList(arrayOfString)
      .stream()
      .map(str -> str.split(":"))
      .collect(toMap(str -> str[0], str -> str[1]));
}

Ici,“:” est le séparateur clé-valeur de tous les éléments du tableau String.

Please remember that in order to avoid compilation error, we need to ensure that code is compiled using Java 1.8. Pour ce faire, nous devons ajouter le plugin suivant dans lespom.xml: 


    
      
        org.apache.maven.plugins
        maven-compiler-plugin
        3.3
        
          1.8
          1.8

5. Essai

Puisque nous avons fini de créer les fonctions, créons des cas de test pour vérifier le résultat.

Tout d'abord, testons notre méthode de jointure simple: 

@Test
public void givenArray_transformedToStream_convertToString() {
    String[] programmingLanguages = {"java", "python", "nodejs", "ruby"};
    String expectation = "java,python,nodejs,ruby";

    String result  = JoinerSplitter.join(programmingLanguages);
    assertEquals(result, expectation);
}

Ensuite, créons-en un autre pour tester notre fonctionnalité de fractionnement simple: 

@Test
public void givenString_transformedToStream_convertToList() {
    String programmingLanguages = "java,python,nodejs,ruby";

    List expectation = new ArrayList<>();
    expectation.add("java");
    expectation.add("python");
    expectation.add("nodejs");
    expectation.add("ruby");

    List result  = JoinerSplitter.split(programmingLanguages);

    assertEquals(result, expectation);
}

Enfin, testons notre tableauString pour mapper les fonctionnalités: 

@Test
public void givenStringArray_transformedToStream_convertToMap() {

    String[] programming_languages = new String[] {"language:java","os:linux","editor:emacs"};

    Map expectation=new HashMap<>();
    expectation.put("language", "java");
    expectation.put("os", "linux");
    expectation.put("editor", "emacs");

    Map result = JoinerSplitter.arrayToMap(programming_languages);
    assertEquals(result, expectation);

}

De la même manière, nous devons créer le reste des cas de test.

6. Conclusion

L'API deStream nous fournit des techniques de traitement de données sophistiquées. Cette nouvelle manière d'écrire du code est très efficace en termes de gestion de la mémoire de tas dans un environnement multithread.

Comme toujours, le code source complet est disponibleover on Github.

Related