Comment convertir un tableau de caractères en chaîne en Java
Une chaîne est définie comme une collection de caractères. Un tableau de caractères diffère d'une chaîne en ce que la chaîne se termine par le caractère spécial « \0 ». Une chaîne est transformée à partir d'un tableau de caractères et vice versa. Nous envisagerons de convertir un tableau de caractères en chaîne dans cet article.
Méthodes :
- Utilisation de la méthode copyOf() de la classe Arrays
- Utiliser la classe StringBuilder
- Utilisation de la méthode valueOf() de la classe String
- Utilisation de la méthode copyValueOf() de la classe String
- Utilisation des collecteurs dans les flux
- Utilisation du constructeur de classe String
Examinons chacune des méthodes en détail et implémentons-les à l'aide d'un programme Java propre.
Convertir un tableau de caractères en chaîne en Java
Fonction 1 :Utilisation de la méthode copyOf() de la classe Array
Le constructeur String accepte le caractère fourni comme argument. Les tableaux sont utilisés pour copier le contenu du tableau de caractères par défaut. La classe Arrays a une fonction copyOf().
Exemple :Un programme pour convertir un tableau de caractères en chaîne en Java
// Using copyOf() method ofArrays class
// Main class
class CodeunderscoredArrayClass {
// Method 1
// To convert a character
// array to a string using the constructor
public static String toString(char[] a)
{
// Creating object of String class
String string = new String(a);
return string;
}
// Main driver method
public static void main(String args[])
{
// Character array
char s[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
// Printing converted string from character array
System.out.println(toString(s));
}
} Méthode 2 :Utilisation de la classe StringBuilder
Et si nous voulions créer une chaîne à partir d'une collection de tableaux de caractères ? Ensuite, nous pouvons créer un objet StringBuilder et utiliser sa fonction append(char[]) pour joindre tous les éléments ensemble.
La classe StringBuilder est également utilisée pour transformer un tableau de caractères en chaîne. L'idée est de parcourir le tableau de caractères et d'attacher chaque caractère à la fin de la chaîne car un StringBuilder est une classe modifiable. Enfin, la chaîne contient la forme de chaîne de caractères. Plus tard, nous utiliserons la méthode toString() pour récupérer sa représentation String.
La méthode append() de la classe StringBuilder ajoute la représentation sous forme de chaîne du tableau char[].
Il analyse le paramètre à ajouter str. Cet objet est retourné comme référence. Cette fonction fonctionne comme String.valueOf(char[]), sauf que les caractères de cette chaîne sont ajoutés à cette séquence de caractères.
La syntaxe est la suivante :
public StringBuilder append(char[] str)
La méthode toString()
La méthode toString() de la classe StringBuilder renvoie une chaîne représentant les données de la séquence. Il crée un nouvel objet String et définit sa valeur initiale sur la séquence de caractères. Toutes les modifications que nous apportons au tableau char[] n'affectent pas la chaîne fraîchement formée.
La syntaxe est la suivante :
public String toString()
Pour convertir le tableau char[] en chaîne dans l'exemple suivant, nous avons utilisé les méthodes append() et toString() de la classe StringBuilder.
Exemple :Programme de conversion d'un tableau de caractères en chaîne en Java
// Using StringBuilder class
// importing required classes
import java.util.*;
// Main class
public class CodeunderscoredCharacterArray {
// Method
for con vert a character array to a string
// using the StringBuilder class
public static String toString(char[] theChar)
{
// Creating object of String class
StringBuilder stringBuilder = new StringBuilder();
// Creating a string using append() method
for (int i = 0; i < theChar.length; i++) {
stringBuilder.append(theChar[i]);
}
return stringBuilder.toString();
}
// The Main driver method
public static void main(String args[])
{
// Custom input as character array
char charArray[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
// Printing the string
// corresponding to character array
System.out.println(toString(charArray));
}
}
Exemple :Générateur de chaînes
@Test
public void StringBuilderOK() {
final char[][] arrayOfCharArray = { { 'c', 'o' }, { 'd', 'e', 'u', 'n' }, { 'd', 'e', 'r', 's', 'c', 'o', 'e', 'd' } };
StringBuilder stringBuilder = new StringBuilder();
for (char[] subArray : arrayOfCharArray) {
stringBuilder.append(subArray);
}
assertThat(sb.toString(), is("codeunderscored"));
} Nous pouvons rendre le code suivant encore plus efficace en créant un StringBuilder avec la longueur requise.
Exemple :tableau de caractères en chaîne à l'aide de StringBuilder
public class CodeCharArrayToString
{
public static void main(String[] args)
{
//character array
char[] charVals = {'C', 'o', 'd', 'e', ' ', 'U', 'n', 'd', 'e', 'r', 's', 'c', 'o', 'r', 'e', 'd'};
//creating an object of the StringBuilder class
StringBuilder stringBuilder = new StringBuilder();
//Java for-each loop
for(char ch: charVals)
{
// the method appends the representation of the string as a char array
stringBuilder.append(ch);
}
//the toString() method is responsible for returning a string that represents data in the sequence
String stringVal = stringBuilder.toString();
//prints the string
System.out.println(stringVal);
}
} Fonction 3 :Utilisation de la méthode valueOf() de la classe String
La fonction valueOf() de la classe String est également utilisée pour convertir un tableau de caractères en chaîne.
Cette méthode modifie automatiquement le tableau de caractères dans un format qui affiche la valeur entière des caractères du tableau. Cette fonction convertit une chaîne à partir d'un entier, d'un flottant, d'un double, d'un char, d'un booléen ou même d'un objet. Nous atteindrons notre objectif en transformant notre tableau de caractères en une chaîne.
Dans l'exemple suivant, nous avons généré un tableau char[] nommé charArray. Après cela, nous avons utilisé la méthode valueOf() de la classe String pour analyser un char[] charArray en elle. Ce dernier renvoie la séquence de caractères que nous avons spécifiée dans le paramètre.
Exemple :Un programme pour convertir un tableau de caractères en chaîne en Java
// Using valueOf() method of String class
// Main class
class CodeunderscoredCharacterArrayToString {
// Method 1
// To convert a character array to string
// using the valueOf() method
public static String toString(char[] theChar)
{
// Creating an object of String class
String strVal = String.valueOf(theChar);
return strVal;
}
// Method 2
// Main driver method
public static void main(String args[])
{
// Custom input character array
char charArray[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
// Print the corresponding string to
// character array
System.out.println(toString(charArray));
}
} Dans la section suivante, nous examinons un autre exemple où la méthode valueOf() convertit un tableau de caractères en une chaîne.
La première étape consiste à créer un tableau de caractères comme suit :
char[] arrVal = { 'c', 'o', 'd', 'e' }; Ensuite, la méthode valueOf() prendra le relais pour convertir le tableau entier en une chaîne, comme indiqué ci-dessous.
String strVal = String.valueOf(arr);
Nous rassemblons ensuite tous ces éléments dans une fonction complète appelée CodeunderscoredValueOf(), comme illustré ci-dessous.
public class CodeunderscoredValueOf {
public static void main(String []args) {
char[] arrVal = { 'c', 'o', 'd', 'e' };
String strVal = String.valueOf(arrVal);
System.out.println(strVal);
}
} Fonction 4 :Utilisation de la méthode copyValueOf() de la classe String
Elle fonctionne comme la méthode valueOf(). La méthode copyValueOf() de la classe String est également une méthode statique. Un tableau char[] est également analysé. De plus, il renvoie la séquence de caractères (String) que nous avons spécifiée dans le paramètre.
Le contenu du tableau de caractères est copié puis modifié sans impact sur la chaîne à renvoyer. Cette approche nous permet également de convertir le tableau de caractères en chaîne, comme le montre l'exemple suivant.
Exemple :programme de conversion d'un tableau de caractères en chaîne en Java
// Using copyValueOf() method of String class
// Importing String class
import java.util.*;
// Main class
class CodeunderscoredCharacterArrayToString {
// Main driver method
public static void main(String[] args) {
// Customly declaring an input character array
char charArray[] = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
// Using copyValueOf() over string and
// storing it in a string
String strVal = String.copyValueOf(arr);
// Printing the converted string corresponding
// character array
System.out.print(strVal);
}
} Regardons un autre exemple où la méthode copyValueOf() est utilisée pour convertir un tableau de caractères en chaîne.
public class CodeunderscoredCopyValueOf {
public static void main(String []args) {
char[] arrVal = { 'c', 'o', 'd', 'e' };
String strVal = String.copyValueOf(arrVal, 1, 2);
System.out.println(strVal);
}
} String#copyValueOf est une méthode sémantiquement équivalente à la méthode valueOf(), mais elle n'était utile que dans les premières versions de Java. La fonction copyValueOf() est obsolète à ce jour, et nous ne préconisons pas de l'utiliser.
Fonction 5 :Utilisation des collecteurs dans les flux en Java
Avec l'avènement des flux en java8, nous utilisons immédiatement les collecteurs dans les flux pour modifier les membres de notre tableau d'entrée de caractères, puis utilisons la méthode join() pour renvoyer une seule chaîne, que nous imprimons ensuite.
Exemple :Programme de conversion d'un tableau de caractères en chaîne en Java
// Using Collectors in Streams in Java8
// Importing Collectos and Stream classes
// from java.util.stream package
import java.util.stream.Collectors;
import java.util.stream.Stream;
// Main class
class CodeunderscoredCharacterArrayToString {
// Main driver method
public static void main(String[] args)
{
// Custom input character array
char[] charVal = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
// Using collectors array elements collection and
// subsequently using the join method to return a single
// string
String strVal = Stream.of(charVal)
.map(arr -> new String(arr))
.collect(Collectors.joining());
// Printing the stream received from Collectors
System.out.println(strVal);
}
} Nous pouvons ouvrir un flux sur un tableau de type T en utilisant la méthode Arrays.stream(T[] object). Par la suite, nous pouvons utiliser la fonction Collectors.joining() pour créer une chaîne avec un tableau de caractères.
@Test
public void StreamCollectors() {
final Character[] charArray = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
Stream<Character> charStream = Arrays.stream(charArray);
String stringVal = charStream.map(String::valueOf).collect(Collectors.joining());
assertThat(stringVal, is("codeunderscored"));
} L'inconvénient de cette technique est que nous exécutons valueOf() sur chaque élément Character, ce qui sera lent.
Exemple :Utilisation de l'objet String et utilisation de la méthode valueOf
Cet exemple montre comment convertir un tableau de caractères en une chaîne en utilisant à la fois la méthode valueOf() de la classe String et la création d'un objet String en transmettant le nom du tableau au constructeur. Nous avons un tableau de caractères ch, et nous avons utilisé le tableau de caractères pour construire deux chaînes, str et str1.
class CharArrayToString
{
public static void main(String args[])
{
// Method 1: Using String object
char[] charVal = {'g', 'o', 'o', 'd', ' ', 'm', 'o', 'r', 'n', 'i', 'n', 'g'};
String strVal = new String(charVal);
System.out.println(strVal);
// Method 2: Using valueOf method
String strTwoVal = String.valueOf(charVal);
System.out.println(strTwoVal);
}
} Guava Joiner (Base commune)
Supposons que la chaîne que nous essayons de créer soit une chaîne délimitée. Guava nous fournit une méthode utile :
@Test
public void GuavaCommonBaseJoiners() {
final Character[] charArray = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
String stringJoiner = Joiner.on("|").join(charArray);
assertThat(stringJoiner, is("c|o|d|e|u|d|e|r|s|c|o|r|e|d"));
} Il convient de noter que la méthode join() n'accepte qu'un tableau de caractères, pas un tableau de caractères bruts.
Construire un constructeur de classe de chaîne
Un constructeur de la classe String prend un tableau char[] comme argument et alloue une nouvelle chaîne. Il indique l'ordre dans lequel les caractères apparaissent (chaîne). La chaîne fraîchement formée reste inchangée si nous modifions le tableau char[].
La syntaxe est la suivante :
public String (char[] value)
Où char[] est la valeur de départ de la chaîne, nous avons ensuite construit un tableau de caractères appelé chVal dans l'exemple ci-dessous. Après cela, nous avons développé un constructeur String qui prend le tableau char[] chVal comme paramètre et l'analyse. Le tableau char[] est converti en chaîne.
public class CharArrayToStringConstructor
{
public static void main(String args[])
{
//character array
char[] chVal = { 'c', 'o', 'd', 'e', 'u', 'n', 'd','e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
//String class's constructor that parses char array as a parameter
String stringVal = new String(chVal);
//prints the string
System.out.println(stringVal);
}
} Conclusion
Cet article a exploré la conversion d'un tableau de caractères en sa représentation String en Java. Pour convertir un tableau de caractères en chaîne en Java, utilisez la fonction valueOf(). La méthode valueOf() est une méthode statique de classe String que vous pouvez utiliser pour convertir un tableau char[] en chaîne. La méthode analyse un tableau char[] en tant qu'argument. Ensuite, il renvoie une chaîne nouvellement allouée avec la même séquence de caractères que le tableau de caractères. La chaîne fraîchement formée reste inchangée si nous modifions le tableau char[].
De plus, la méthode copyValueOf() peut également être utilisée pour représenter la séquence de caractères dans le tableau donné. Elle renvoie une chaîne contenant les caractères du tableau de caractères fourni.
Le constructeur de la classe String est surchargé à divers endroits. String(char[]) est un constructeur qui prend un tableau de caractères comme argument. Il crée ensuite une nouvelle chaîne pour refléter la séquence de caractères fournie dans le paramètre tableau de caractères.
