Concaténer des éléments d'un tableau en une chaîne
Je suis un peu confus. Je n'ai trouvé la réponse nulle part
J'ai un tableau de chaînes:
String[] arr = ["1", "2", "3"];
puis je le convertis en chaîne par:
String str = Arrays.toString(arr);
System.out.println(str);
Je m'attendais à obtenir la chaîne "123", mais j'ai plutôt la chaîne "[1,2,3]".
Comment pourrais-je le faire en Java? J'utilise Eclipse IDE
Utilisez StringBuilder au lieu de StringBuffer, car il est plus rapide que StringBuffer .
String[] strArr = {"1", "2", "3"};
StringBuilder strBuilder = new StringBuilder();
for (int i = 0; i < strArr.length; i++) {
strBuilder.append(strArr[i]);
}
String newString = strBuilder.toString();
Voici pourquoi il s'agit d'une meilleure solution pour utiliser la concaténation de chaînes: Lorsque vous concaténez 2 chaînes, un nouvel objet chaîne est créé et une copie caractère par caractère est effectuée.
Ce qui signifie effectivement que la complexité du code serait l’ordre du carré de la taille de votre tableau!
(1+2+3+ ... n qui correspond au nombre de caractères copiés par itération).StringBuilder effectuerait la "copie vers une chaîne" une seule fois dans ce cas, en réduisant la complexité à O(n).
Arrays.toString(arr);
la sortie est [1,2,3] et vous la stockez dans votre chaîne. et l’imprimer pour obtenir le résultat [1,2,3].
Si vous voulez obtenir le résultat 123, essayez ceci:
public static void main(String[] args) {
String[] arr= {"1","2","3"};
String output ="";
for(String str: arr)
output=output+str;
System.out.println(output);
}
Sortie:
123
Utilisez la fonction Arrays.toString (). Il garde votre code court et lisible. Il utilise un constructeur de chaînes en interne, donc, il est également efficace. Pour vous débarrasser des caractères supplémentaires, vous pouvez choisir de les éliminer à l'aide de la fonction String.replace (), ce qui, certes, réduit à nouveau la lisibilité.
String str = Arrays.toString(arr).replaceAll(", |\\[|\\]", "");
Ceci est similaire à la réponse de Tris Nefzger, mais sans la longue construction de sous-chaîne pour supprimer les crochets.
Explication de l'expression rationnelle: "|" signifie l'un de "," et "[" et "]". Le "\\" indique à la chaîne Java que nous ne voulons pas dire un caractère spécial (comme une nouvelle ligne "\ n" ou un onglet "\ t"), mais une vraie barre oblique inversée "\". Ainsi, au lieu de "\\ [", l'interprète Regex lit "\ [", ce qui lui indique qu'il s'agit d'un crochet littéral et que vous ne voulez pas l'utiliser dans le langage Regex (par exemple, " ^ 3] * "désigne un nombre quelconque de caractères, mais aucun d'entre eux ne doit être" 3 ").
Arrays.toString: (à partir de l'API, au moins pour la version Object[] de celle-ci)
public static String toString(Object[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(String.valueOf(a[i]));
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
Cela signifie donc qu’il insère le [ au début, le ] à la fin et le , entre les éléments.
Si vous le voulez sans ces caractères: (StringBuilder est plus rapide que ce qui suit, mais cela ne peut pas être une petite quantité de code)
String str = "";
for (String i:arr)
str += i;
System.out.println(str);
Note latérale:
String[] arr[3]= [1,2,3] ne compilera pas.
Vous vouliez probablement: String[] arr = {"1", "2", "3"};
Guava a l’utilitaire Joiner pour résoudre ce problème:
Exemple:
String joinWithoutSeparator = Joiner.on("").join(1, 2, 3); // returns "123"
String joinWithSeparator = Joiner.on(",").join(1, 2, 3); // returns "1,2,3"
Je viens d'écrire le texte suivant:
public static String toDelimitedString(int[] ids, String delimiter)
{
StringBuffer strb = new StringBuffer();
for (int id : ids)
{
strb.append(String.valueOf(id) + delimiter);
}
return strb.substring(0, strb.length() - delimiter.length());
}
Utilisation de Joiner de Guava (qui en r18 utilise StringBuilder en interne)
String[] arr= {"1","2","3"};
Joiner noSpaceJoiner = Joiner.on("");
noSpaceJoiner.join(arr))
Joiner est utile car il est thread-safe et immuable et peut être réutilisé à de nombreux endroits sans avoir à dupliquer du code. À mon avis, il est également plus lisible.
En utilisant Stream support de Java 8, nous pouvons également réduire ce nombre à une seule ligne.
String concat = Stream.of(arr).collect(Collectors.joining());
Les deux sorties dans ce cas sont 123
Ceci est un petit code de convert string array en string sans [ ni ] ni ,
String[] strArray = new String[]{"Java", "String", "Array", "To", "String", "Example"};
String str = Arrays.toString(strArray);
str = str.substring(1, str.length()-1).replaceAll(",", "");
- Convertissez d'abord le tableau en chaîne.
- Deuxièmement, obtenez le texte de x à la position y.
- troisième remplacer tout ',' avec ""
Pour les projets basés au printemps:
org.springframework.util.StringUtils.arrayToDelimitedString (Object [] arr, String delim)
Pour les utilisateurs d'Apache Commons, ensemble de méthodes de jointure de Nice:
org.Apache.commons.lang.StringUtils.join (tableau Object [], séparateur de caractères)
Arrays.toString est le formatage de la sortie (ajouté les crochets et les virgules). vous devriez implémenter votre propre méthode de toString.
public String toString(String[] arr){
String result = "";
for(String s : arr)
result+=s;
return result;
}
[edit] Stringbuilder est meilleur cependant. voir au dessus.
jetez un oeil à méthode générique pour imprimer tous les éléments d'un tableau
mais en bref, Arrays.toString (arr) n'est qu'un moyen facile d'imprimer le contenu d'un tableau primatif.
La classe d'objet a la méthode toString. Toutes les autres classes qui l'étendent remplacent la méthode toString. Ainsi, pour les tableaux, toString est également remplacé. Donc, si vous voulez que votre sortie corresponde à votre chemin, vous devez créer votre propre méthode par laquelle vous obtiendrez le résultat souhaité.
str="";
for (Integer i:arr){
str+=i.toString();
}
J'espère que cela t'aides
refer Pourquoi la méthode toString en Java ne semble pas fonctionner pour un tableau
Arrays.toString () peut être utilisé pour convertir String Array en String. Les caractères supplémentaires peuvent être supprimés à l'aide d'expressions Regex ou simplement à l'aide de la méthode replace.
Arrays.toString(strArray).replace(",", "").replace("[", "").replace("]", "");
Java 8 a introduit une nouvelle méthode pour la jointure String Public statique String join (délimiteur CharSequence, éléments CharSequence ...)
String.join("", strArray);
Voici une façon de le faire: Arrays.toString (array) .sstrstr (1, (3 * array.length-1)). ReplaceAll (",", "");
Voici un cours de démonstration:
package arraytostring.demo;
import Java.util.Arrays;
public class Array2String {
public static void main(String[] args) {
String[] array = { "1", "2", "3", "4", "5", "6", "7" };
System.out.println(array2String(array));
// output is: 1234567
}
public static String array2String(String[] array) {
return Arrays.toString(array).substring(1, (3 * array.length - 1))
.replaceAll(", ", "");
}
}
Scala rend cela plus facile, plus propre et plus sûr:
scala> val a = Array("1", "2", "3")
a: Array[String] = Array(1, 2, 3)
scala> val aString = a.mkString
aString: String = 123
scala> println(aString)
123
Exemple utilisant Java 8.
String[] arr = {"1", "2", "3"};
String join = String.join("", arr);
J'espère que ça aide
Pour ceux qui développent sous Android, utilisez TextUtils.
String items = TextUtils.join("", arr);
En supposant que arr est de type String[] arr= {"1","2","3"};
La sortie serait 123