Opérations de chaîne courantes en Java

1. Introduction

Les valeurs et les opérations basées sur des chaînes sont assez courantes dans le développement quotidien, et tout développeur Java doit être capable de les gérer.

Dans ce didacticiel, nous fournirons une aide-mémoire rapide sur les opérations String courantes.

De plus, nous allons faire la lumière sur les différences entre equals et «==» et entre StringUtils # isBlank et # isEmpty.

2. Transformer un caractère en chaîne

Un char représente un caractère en Java. Mais dans la plupart des cas, nous avons besoin d'une chaîne.

Commençons donc par transformer char s en String s :

String toStringWithConcatenation(final char c) { return String.valueOf(c); }

3. Ajout de chaînes

Une autre opération fréquemment nécessaire consiste à ajouter des chaînes avec d'autres valeurs, comme un char :

String appendWithConcatenation(final String prefix, final char c) { return prefix + c; }

Nous pouvons ajouter d' autres types de base avec un StringBuilder ainsi :

String appendWithStringBuilder(final String prefix, final char c) { return new StringBuilder(prefix).append(c).toString(); }

4. Obtenir un personnage par index

Si nous devons extraire un caractère d'une chaîne, l'API fournit tout ce que nous voulons:

char getCharacterByIndex(final String text, final int index) { return text.charAt(index); }

Puisqu'un String utilise un char [] comme structure de données de sauvegarde, l'index commence à zéro .

5. Gestion des valeurs ASCII

On peut facilement basculer entre un omble chevalier et sa représentation numérique (ASCII) par coulée:

int asciiValue(final char character) { return (int) character; } char fromAsciiValue(final int value) { Assert.isTrue(value >= 0 && value < 65536, "value is not a valid character"); return (char) value; }

Bien sûr, comme un int est de 4 octets non signés et un char est de 2 octets non signés, nous devons vérifier que nous travaillons avec des valeurs de caractères légaux.

6. Suppression de tous les espaces

Parfois, nous devons nous débarrasser de certains caractères, le plus souvent des espaces. Un bon moyen consiste à utiliser la méthode replaceAll avec une expression régulière:

String removeWhiteSpace(final String text) { return text.replaceAll("\\s+", ""); }

7. Joindre des collections à une chaîne

Un autre cas d'utilisation courant est celui où nous avons une sorte de Collection et que nous voulons en créer une chaîne:

 String fromCollection(final Collection collection) { return collection.stream().map(Objects::toString).collect(Collectors.joining(", ")); }

Notez que le Collectors.joining permet de spécifier le préfixe ou le suffixe.

8. Fractionner une chaîne

Ou d'un autre côté, nous pouvons diviser une chaîne par un délimiteur en utilisant la méthode split :

String[] splitByRegExPipe(final String text)  return text.split("\\

Encore une fois, nous utilisons une expression régulière ici, cette fois pour diviser par un tuyau. Puisque nous voulons utiliser un caractère spécial, nous devons y échapper.

Une autre possibilité est d'utiliser la classe Pattern :

String[] splitByPatternPipe(final String text) ")); 

9. Traitement de tous les caractères en tant que flux

Dans le cas d'un traitement détaillé, nous pouvons transformer une chaîne en IntStream :

IntStream getStream(final String text) { return text.chars(); }

10. Égalité de référence et égalité de valeur

Bien que les chaînes ressemblent à un type primitif, elles ne le sont pas.

Par conséquent, nous devons faire la distinction entre l'égalité de référence et l'égalité des valeurs. L'égalité de référence implique toujours l'égalité des valeurs, mais en général pas l'inverse. Le premier, on vérifie avec l'opération '==' et le second, avec la méthode equals :

@Test public void whenUsingEquals_thenWeCheckForTheSameValue() { assertTrue("Values are equal", new String("Test").equals("Test")); } @Test public void whenUsingEqualsSign_thenWeCheckForReferenceEquality() { assertFalse("References are not equal", new String("Test") == "Test"); }

Notez que les littéraux sont internés dans le pool de chaînes. Par conséquent, le compilateur peut parfois les optimiser avec la même référence:

@Test public void whenTheCompileCanBuildUpAString_thenWeGetTheSameReference() { assertTrue("Literals are concatenated by the compiler", "Test" == "Te"+"st"); }

11. Chaîne vide et chaîne vide

Il existe une différence subtile entre isBlank et isEmpty .

Une chaîne est vide si elle est nulle ou a une longueur de zéro. Alors qu'une chaîne est vide si elle est nulle ou ne contient que des espaces blancs:

@Test public void whenUsingIsEmpty_thenWeCheckForNullorLengthZero() { assertTrue("null is empty", isEmpty(null)); assertTrue("nothing is empty", isEmpty("")); assertFalse("whitespace is not empty", isEmpty(" ")); assertFalse("whitespace is not empty", isEmpty("\n")); assertFalse("whitespace is not empty", isEmpty("\t")); assertFalse("text is not empty", isEmpty("Anything!")); } @Test public void whenUsingIsBlank_thenWeCheckForNullorOnlyContainingWhitespace() { assertTrue("null is blank", isBlank(null)); assertTrue("nothing is blank", isBlank("")); assertTrue("whitespace is blank", isBlank("\t\t \t\n\r")); assertFalse("test is not blank", isBlank("Anything!")); }

12. Conclusion

Les chaînes sont un type de base dans toutes sortes d'applications. Dans ce didacticiel, nous avons appris certaines opérations clés dans des scénarios courants.

De plus, nous avons donné des instructions à des références plus détaillées.

Enfin, le code complet avec tous les exemples est disponible dans notre référentiel GitHub.