Rejoindre un tableau de primitives avec séparateur en Java

1. Introduction

Dans ce rapide didacticiel, nous allons apprendre à joindre un tableau de primitives avec un séparateur à un seul caractère en Java . Pour nos exemples, nous considérerons deux tableaux: un tableau de int et un tableau de char .

2. Définition du problème

Commençons par définir un tableau d' int et un tableau de char pour les exemples, ainsi que le caractère séparateur que nous utiliserons pour joindre leur contenu:

int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9}; char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'}; char separatorChar = '-'; String separator = String.valueOf(separatorChar); 

Notez que nous avons inclus un séparateur char et String car certaines des méthodes que nous montrerons nécessitent un argument char , tandis que d'autres nécessitent un argument String .

Les résultats de l'opération de jointure contiendront «1-2-3-4-5-6-7-8-9» pour le tableau int et «abcdef» pour le tableau char .

3. Collectors.joining ()

Commençons par l'une des méthodes disponibles de l'API Java 8 Stream - Collectors.joining () .

Tout d'abord, nous créons un Stream à partir d'un tableau de primitives en utilisant la méthode Arrays.stream () trouvée dans le package java.util . Ensuite, nous mappons chaque élément à String . Et enfin, nous concaténons les éléments avec notre séparateur donné.

Commençons par notre tableau int :

String joined = Arrays.stream(intArray) .mapToObj(String::valueOf) .collect(Collectors.joining(separator));

Lors de la jonction de notre tableau char avec cette méthode, nous devons d'abord envelopper le tableau char dans CharBuffer , puis le projeter à nouveau sur char . En effet, la méthode chars () renvoie un Stream de valeurs int .

Malheureusement, l'API Java Stream ne fournit pas de méthode native pour encapsuler un Stream of char .

Joignons notre omble chevalier tableau:

String joined = CharBuffer.wrap(charArray).chars() .mapToObj(intValue -> String.valueOf((char) intValue)) .collect(Collectors.joining(separator));

4. StringJoiner

De la même manière que Collectors.joining () , cette approche utilise l'API Stream, mais au lieu de collecter des éléments, elle parcourt les éléments et les ajoute à une instance StringJoiner :

StringJoiner intStringJoiner = new StringJoiner(separator); Arrays.stream(intArray) .mapToObj(String::valueOf) .forEach(intStringJoiner::add); String joined = intStringJoiner.toString();

Encore une fois, nous devons envelopper notre omble chevalier tableau dans CharBuffer lorsque vous utilisez l'API Stream

StringJoiner charStringJoiner = new StringJoiner(separator); CharBuffer.wrap(charArray).chars() .mapToObj(intChar -> String.valueOf((char) intChar)) .forEach(charStringJoiner::add); String joined = charStringJoiner.toString();

5. Apache Commons Lang

La bibliothèque Apache Commons Lang fournit des méthodes pratiques dans les classes StringUtils et ArrayUtils que nous pouvons utiliser pour joindre nos tableaux primitifs.

Pour utiliser cette bibliothèque, nous devrons ajouter la dépendance commons-lang3 à notre pom.xml :

 org.apache.commons commons-lang3 3.8.1 

Lorsque vous travaillez avec un séparateur de chaîne , nous utiliserons à la fois StringUtils et ArrayUtils .

Utilisons-les ensemble pour joindre notre tableau int :

String joined = StringUtils.join(ArrayUtils.toObject(intArray), separator);

Ou, si nous utilisons un type char primitif comme séparateur, nous pouvons simplement écrire:

String joined = StringUtils.join(intArray, separatorChar);

Les implémentations pour joindre notre tableau char sont assez similaires:

String joined = StringUtils.join(ArrayUtils.toObject(charArray), separator);

Et lorsque vous utilisez un omble chevalier séparateur:

String joined = StringUtils.join(charArray, separatorChar);

6. Goyave

La bibliothèque Guava de Google fournit la classe Joiner que nous pouvons utiliser pour joindre nos tableaux. Pour utiliser Guava dans notre projet, nous devons ajouter la dépendance goyava Maven:

 com.google.guava guava 27.0.1-jre 

Joignons notre tableau int en utilisant la classe Joiner :

String joined = Joiner.on(separator).join(Ints.asList(intArray));

Dans cet exemple, nous avons également utilisé la méthode Ints.asList () de Guava, qui transforme joliment le tableau de primitives en une liste d' entiers .

Goyave propose une méthode similaire pour la conversion d' un omble chevalier tableau à une liste de caractères. En conséquence, la jonction de notre tableau char ressemble beaucoup à l'exemple ci-dessus qui utilisait le tableau int :

String joined = Joiner.on(separator).join(Chars.asList(charArray));

7. StringBuilder

Enfin, si nous ne pouvons utiliser ni Java 8 ni des bibliothèques tierces, nous pouvons joindre manuellement un tableau d'éléments avec StringBuilder . Dans ce cas, l'implémentation est identique pour les deux types de tableaux:

if (array.length == 0) { return ""; } StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < array.length - 1; i++) { stringBuilder.append(array[i]); stringBuilder.append(separator); } stringBuilder.append(array[array.length - 1]); String joined = stringBuilder.toString();

8. Conclusion

Cet article rapide illustre un certain nombre de façons de joindre un tableau de primitives avec un caractère ou une chaîne de séparation donné. Nous avons montré des exemples utilisant des solutions JDK natives, ainsi que des solutions supplémentaires utilisant deux bibliothèques tierces - Apache Commons Lang et Guava.

Comme toujours, le code complet utilisé dans cet article est disponible à l'adresse over sur GitHub.