Je veux rejoindre un String[]
avec une chaîne de colle. Y a-t-il une fonction pour cela?
Je veux rejoindre un String[]
avec une chaîne de colle. Y a-t-il une fonction pour cela?
Réponses:
À partir de Java8, il est possible d'utiliser String.join()
.
String.join(", ", new String[]{"Hello", "World", "!"})
Génère:
Hello, World, !
Sinon, Apache Commons Lang a une StringUtils
classe qui a une join
fonction qui réunira les tableaux pour faire un String
.
Par exemple:
StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")
Génère les éléments suivants String
:
Hello, World, !
String.join()
méthode introduite dans Java 8. De cette façon, le grand nombre de personnes lisant cette réponse acceptée bénéficiera de cette connaissance. Actuellement, la réponse la plus votée mentionnant ce fait est plutôt perdue ci-dessous ...
String.join()
ne fonctionnerait que pour les éléments List<CharSequence>
ou CharSequence[]
.
Si vous cherchiez quoi utiliser dans Android, c'est:
String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)
par exemple:
String joined = TextUtils.join(";", MyStringArray);
Dans Java 8, vous pouvez utiliser
1) API de diffusion:
String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));
2) nouvelle méthode String.join: https://stackoverflow.com/a/21756398/466677
3) Classe java.util.StringJoiner: http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html
Vous pouvez facilement écrire une telle fonction dans une dizaine de lignes de code:
String combine(String[] s, String glue)
{
int k = s.length;
if ( k == 0 )
{
return null;
}
StringBuilder out = new StringBuilder();
out.append( s[0] );
for ( int x=1; x < k; ++x )
{
out.append(glue).append(s[x]);
}
return out.toString();
}
Un petit mod au lieu d'utiliser substring ():
//join(String array,delimiter)
public static String join(String r[],String d)
{
if (r.length == 0) return "";
StringBuilder sb = new StringBuilder();
int i;
for(i=0;i<r.length-1;i++){
sb.append(r[i]);
sb.append(d);
}
sb.append(r[i]);
return sb.toString();
}
.append()
deux fois pour chacun String
au lieu de les concaténer puis de les ajouter au générateur.
Comme pour de nombreuses questions ces derniers temps, Java 8 à la rescousse:
Java 8 a ajouté une nouvelle méthode statique java.lang.String
qui fait exactement ce que vous voulez:
public static String join(CharSequence delimeter, CharSequence... elements);
En l'utilisant:
String s = String.join(", ", new String[] {"Hello", "World", "!"});
Résulte en:
"Hello, World, !"
La bibliothèque de Google goyave a également ce genre de capacité . Vous pouvez également voir l'exemple String [] dans l'API.
Comme déjà décrit dans l'API, méfiez-vous de l'immuabilité des méthodes de construction.
Il peut accepter un tableau d'objets afin que cela fonctionne dans votre cas. Dans mon expérience précédente, j'ai essayé de rejoindre une pile qui est un itérable et cela fonctionne très bien.
Échantillon de moi:
Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");
imprime: |i am a coder|
Donné:
String[] a = new String[] { "Hello", "World", "!" };
Ensuite, comme alternative à la réponse de coobird, où la colle est ",":
Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")
Ou pour concaténer avec une chaîne différente, telle que "& amp;".
Arrays.asList(a).toString().replaceAll(", ", " & ").replaceAll("^\\[|\\]$", "")
Cependant ... celui-ci fonctionne UNIQUEMENT si vous savez que les valeurs du tableau ou de la liste NE contiennent PAS la chaîne de caractères ",".
Arrays.asList(a).toString()
travaillé pour ce que je voulais faire
Si vous utilisez Spring Framework, vous disposez de la classe StringUtils :
import static org.springframework.util.StringUtils.arrayToDelimitedString;
arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");
Pas dans le noyau, non. Une recherche de "colle de chaîne de jonction de tableau java" vous donnera quelques extraits de code sur la façon d'y parvenir.
par exemple
public static String join(Collection s, String delimiter) {
StringBuffer buffer = new StringBuffer();
Iterator iter = s.iterator();
while (iter.hasNext()) {
buffer.append(iter.next());
if (iter.hasNext()) {
buffer.append(delimiter);
}
}
return buffer.toString();
}
Si vous avez atterri ici à la recherche d'une conversion rapide de tableau en chaîne, essayez Arrays.toString () .
Crée une représentation String du
Object[]
passé. Le résultat est entouré de crochets ("[]"
), chaque élément est converti en une chaîne via leString.valueOf(Object)
et séparé par", "
. Si le tableau l'estnull
, alors"null"
est retourné.
Juste pour le défi "J'ai le plus court" , voici les mines;)
Itératif:
public static String join(String s, Object... a) {
StringBuilder o = new StringBuilder();
for (Iterator<Object> i = Arrays.asList(a).iterator(); i.hasNext();)
o.append(i.next()).append(i.hasNext() ? s : "");
return o.toString();
}
Récursif:
public static String join(String s, Object... a) {
return a.length == 0 ? "" : a[0] + (a.length == 1 ? "" : s + join(s, Arrays.copyOfRange(a, 1, a.length)));
}
copyOfRange()
").
Rien de intégré que je sache.
Apache Commons Lang a une classe appelée StringUtils
qui contient de nombreuses fonctions de jointure.
Voilà comment je le fais.
private String join(String[] input, String delimiter)
{
StringBuilder sb = new StringBuilder();
for(String value : input)
{
sb.append(value);
sb.append(delimiter);
}
int length = sb.length();
if(length > 0)
{
// Remove the extra delimiter
sb.setLength(length - delimiter.length());
}
return sb.toString();
}
Une alternative similaire
/**
* @param delimiter
* @param inStr
* @return String
*/
public static String join(String delimiter, String... inStr)
{
StringBuilder sb = new StringBuilder();
if (inStr.length > 0)
{
sb.append(inStr[0]);
for (int i = 1; i < inStr.length; i++)
{
sb.append(delimiter);
sb.append(inStr[i]);
}
}
return sb.toString();
}
Mon tour.
public static String join(Object[] objects, String delimiter) {
if (objects.length == 0) {
return "";
}
int capacityGuess = (objects.length * objects[0].toString().length())
+ ((objects.length - 1) * delimiter.length());
StringBuilder ret = new StringBuilder(capacityGuess);
ret.append(objects[0]);
for (int i = 1; i < objects.length; i++) {
ret.append(delimiter);
ret.append(objects[i]);
}
return ret.toString();
}
public static String join(Object... objects) {
return join(objects, "");
}
Aimez-vous ma façon de 3 lignes en utilisant uniquement les méthodes de la classe String?
static String join(String glue, String[] array) {
String line = "";
for (String s : array) line += s + glue;
return (array.length == 0) ? line : line.substring(0, line.length() - glue.length());
}
StringBuilder
si vous avez besoin d'efficacité: P
Dans le cas où vous utilisez la bibliothèque Java fonctionnelle et pour une raison quelconque, vous ne pouvez pas utiliser les flux de Java 8 (ce qui pourrait être le cas lorsque vous utilisez le plug-in Android + Retrolambda), voici une solution fonctionnelle pour vous:
String joinWithSeparator(List<String> items, String separator) {
return items
.bind(id -> list(separator, id))
.drop(1)
.foldLeft(
(result, item) -> result + item,
""
);
}
Notez que ce n'est pas l'approche la plus efficace, mais cela fonctionne bien pour les petites listes.
Je le fais de cette façon en utilisant un StringBuilder:
public static String join(String[] source, String delimiter) {
if ((null == source) || (source.length < 1)) {
return "";
}
StringBuilder stringbuilder = new StringBuilder();
for (String s : source) {
stringbuilder.append(s + delimiter);
}
return stringbuilder.toString();
} // join((String[], String)
s + delimiter
(concaténation de chaînes avec l'opérateur plus) annule tout le but de l'utilisation de a StringBuilder
.
Il existe une technique de raccourci simple que j'utilise la plupart du temps.
String op = new String;
for (int i : is)
{
op += candidatesArr[i-1]+",";
}
op = op.substring(0, op.length()-1);
java.util.Arrays a une méthode 'asList'. Avec l'API java.util.List / ArrayList, cela vous donne tout ce dont vous avez besoin :;
private static String[] join(String[] array1, String[] array2) {
List<String> list = new ArrayList<String>(Arrays.asList(array1));
list.addAll(Arrays.asList(array2));
return list.toArray(new String[0]);
}