Java: convertir la liste <String> en une chaîne

JavaScript a Array.join()

js>["Bill","Bob","Steve"].join(" and ")
Bill and Bob and Steve

Java a-t-il quelque chose comme ça? Je sais que je peux bricoler quelque chose avec StringBuilder:

static public String join(List<String> list, String conjunction)
{
   StringBuilder sb = new StringBuilder();
   boolean first = true;
   for (String item : list)
   {
      if (first)
         first = false;
      else
         sb.append(conjunction);
      sb.append(item);
   }
   return sb.toString();
}

... mais cela ne sert à rien si quelque chose comme ça fait déjà partie du JDK.

Avec Java 8, vous pouvez le faire sans aucune bibliothèque tierce.

Si vous souhaitez rejoindre une collection de chaînes, vous pouvez utiliser la nouvelle méthode String.join () :

List<String> list = Arrays.asList("foo", "bar", "baz");
String joined = String.join(" and ", list); // "foo and bar and baz"

Si vous avez une collection avec un autre type que String, vous pouvez utiliser l'API Stream avec le collecteur joint :

List<Person> list = Arrays.asList(
  new Person("John", "Smith"),
  new Person("Anna", "Martinez"),
  new Person("Paul", "Watson ")
);

String joinedFirstNames = list.stream()
  .map(Person::getFirstName)
  .collect(Collectors.joining(", ")); // "John, Anna, Paul"

La StringJoinerclasse peut également être utile.

Toutes les références à Apache Commons sont correctes (et c'est ce que la plupart des gens utilisent) mais je pense que l' équivalent de la goyave , Joiner , a une API beaucoup plus agréable.

Vous pouvez faire le cas de jointure simple avec

Joiner.on(" and ").join(names)

mais aussi gérer facilement les nulls:

Joiner.on(" and ").skipNulls().join(names);

ou

Joiner.on(" and ").useForNull("[unknown]").join(names);

et (assez utile en ce qui me concerne pour l'utiliser de préférence à commons-lang), la possibilité de gérer Maps:

Map<String, Integer> ages = .....;
String foo = Joiner.on(", ").withKeyValueSeparator(" is ").join(ages);
// Outputs:
// Bill is 25, Joe is 30, Betty is 35

ce qui est extrêmement utile pour le débogage, etc.

Pas prêt à l'emploi, mais de nombreuses bibliothèques ont des similitudes:

Commons Lang:

org.apache.commons.lang.StringUtils.join(list, conjunction);

Printemps:

org.springframework.util.StringUtils.collectionToDelimitedString(list, conjunction);

Sur Android, vous pouvez utiliser la classe TextUtils .

TextUtils.join(" and ", names);

Non, il n'y a pas une telle méthode pratique dans l'API Java standard.

Sans surprise, Apache Commons fournit une telle chose dans leur classe StringUtils au cas où vous ne voudriez pas l'écrire vous-même.

Trois possibilités en Java 8:

List<String> list = Arrays.asList("Alice", "Bob", "Charlie")

String result = String.join(" and ", list);

result = list.stream().collect(Collectors.joining(" and "));

result = list.stream().reduce((t, u) -> t + " and " + u).orElse("");

Avec un collecteur java 8, cela peut être fait avec le code suivant:

Arrays.asList("Bill", "Bob", "Steve").stream()
.collect(Collectors.joining(" and "));

De plus, la solution la plus simple en java 8:

String.join(" and ", "Bill", "Bob", "Steve");

ou

String.join(" and ", Arrays.asList("Bill", "Bob", "Steve"));

J'ai écrit celui-ci (je l'utilise pour les beans et l'exploiter toString, alors n'écrivez pas Collection<String>):

public static String join(Collection<?> col, String delim) {
    StringBuilder sb = new StringBuilder();
    Iterator<?> iter = col.iterator();
    if (iter.hasNext())
        sb.append(iter.next().toString());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next().toString());
    }
    return sb.toString();
}

mais Collectionn'est pas pris en charge par JSP, donc pour TLD, j'ai écrit:

public static String join(List<?> list, String delim) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        sb.append(delim);
        sb.append(list.get(i).toString());
    }
    return sb.toString();
}

et mettre au .tlddossier:

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
    <function>
        <name>join</name>
        <function-class>com.core.util.ReportUtil</function-class>
        <function-signature>java.lang.String join(java.util.List, java.lang.String)</function-signature>
    </function>
</taglib>

et l'utiliser dans les fichiers JSP comme:

<%@taglib prefix="funnyFmt" uri="tag:com.core.util,2013:funnyFmt"%>
${funnyFmt:join(books, ", ")}

Le code dont vous disposez est la bonne façon de le faire si vous souhaitez utiliser JDK sans bibliothèque externe. Il n'y a pas de "one-liner" simple que vous pourriez utiliser dans JDK.

Si vous pouvez utiliser des bibliothèques externes, je vous recommande de consulter la classe org.apache.commons.lang.StringUtils dans la bibliothèque Apache Commons.

Un exemple d'utilisation:

List<String> list = Arrays.asList("Bill", "Bob", "Steve");
String joinedResult = StringUtils.join(list, " and ");

Un moyen orthodoxe pour y parvenir, est de définir une nouvelle fonction:

public static String join(String joinStr, String... strings) {
    if (strings == null || strings.length == 0) {
        return "";
    } else if (strings.length == 1) {
        return strings[0];
    } else {
        StringBuilder sb = new StringBuilder(strings.length * 1 + strings[0].length());
        sb.append(strings[0]);
        for (int i = 1; i < strings.length; i++) {
            sb.append(joinStr).append(strings[i]);
        }
        return sb.toString();
    }
}

Échantillon:

String[] array = new String[] { "7, 7, 7", "Bill", "Bob", "Steve",
        "[Bill]", "1,2,3", "Apple ][","~,~" };

String joined;
joined = join(" and ","7, 7, 7", "Bill", "Bob", "Steve", "[Bill]", "1,2,3", "Apple ][","~,~");
joined = join(" and ", array); // same result

System.out.println(joined);

Production:

7, 7, 7 et Bill et Bob et Steve et [Bill] et 1,2,3 et Apple] [et ~, ~

Solution Java 8 avec java.util.StringJoiner

Java 8 a une StringJoinerclasse. Mais vous devez encore écrire un peu de passe-partout, car c'est Java.

StringJoiner sj = new StringJoiner(" and ", "" , "");
String[] names = {"Bill", "Bob", "Steve"};
for (String name : names) {
   sj.add(name);
}
System.out.println(sj);

Vous pouvez utiliser la bibliothèque apache commons qui a une classe StringUtils et une méthode join.

Vérifiez ce lien: https://commons.apache.org/proper/commons-lang/javadocs/api.2.0/org/apache/commons/lang/StringUtils.html

Notez que le lien ci-dessus peut devenir obsolète au fil du temps, auquel cas vous pouvez simplement rechercher sur le Web "apache commons StringUtils", qui devrait vous permettre de trouver la dernière référence.

(référencé à partir de ce fil) Équivalents Java de C # String.Format () et String.Join ()

Tu peux le faire:

String aToString = java.util.Arrays.toString(anArray);
// Do not need to do this if you are OK with '[' and ']'
aToString = aToString.substring(1, aToString.length() - 1);

Ou une ligne (uniquement lorsque vous ne voulez pas «[» et «]»)

String aToString = java.util.Arrays.toString(anArray).substring(1).replaceAll("\\]$", "");

J'espère que cela t'aides.

Une façon amusante de le faire avec du JDK pur, dans une seule ligne de service:

String[] array = new String[] { "Bill", "Bob", "Steve","[Bill]","1,2,3","Apple ][" };
String join = " and ";

String joined = Arrays.toString(array).replaceAll(", ", join)
        .replaceAll("(^\\[)|(\\]$)", "");

System.out.println(joined);

Production:

Bill et Bob et Steve et [Bill] et 1,2,3 et Apple] [

Une manière pas trop parfaite et pas trop amusante!

String[] array = new String[] { "7, 7, 7","Bill", "Bob", "Steve", "[Bill]",
        "1,2,3", "Apple ][" };
String join = " and ";

for (int i = 0; i < array.length; i++) array[i] = array[i].replaceAll(", ", "~,~");
String joined = Arrays.toString(array).replaceAll(", ", join)
        .replaceAll("(^\\[)|(\\]$)", "").replaceAll("~,~", ", ");

System.out.println(joined);

Production:

7, 7, 7 et Bill et Bob et Steve et [Bill] et 1,2,3 et Apple] [

Vous pouvez essayer la méthode de jointure Apache Commons StringUtils:

http://commons.apache.org/lang/api/org/apache/commons/lang/StringUtils.html#join(java.util.Iterator , java.lang.String)

J'ai trouvé qu'Apache StringUtils prend le relais de jdk ;-)

Si vous utilisez des collections Eclipse (anciennement collections GS ), vous pouvez utiliser la makeString()méthode.

List<String> list = Arrays.asList("Bill", "Bob", "Steve");

String string = ListAdapter.adapt(list).makeString(" and ");

Assert.assertEquals("Bill and Bob and Steve", string);

Si vous pouvez convertir votre Listen un type de collections Eclipse, vous pouvez vous débarrasser de l'adaptateur.

MutableList<String> list = Lists.mutable.with("Bill", "Bob", "Steve");
String string = list.makeString(" and ");

Si vous voulez juste une chaîne séparée par des virgules, vous pouvez utiliser la version makeString()qui ne prend aucun paramètre.

Assert.assertEquals(
    "Bill, Bob, Steve", 
    Lists.mutable.with("Bill", "Bob", "Steve").makeString());

Remarque: je suis un committer pour les collections Eclipse.

Avec java 1.8 stream peut être utilisé,

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
List<String> list = Arrays.asList("Bill","Bob","Steve").
String str = list.stream().collect(Collectors.joining(" and "));

ÉDITER

Je remarque également le toString()problème d'implémentation sous - jacent et l'élément contenant le séparateur, mais je pensais que j'étais paranoïaque.

Étant donné que j'ai deux commentaires à ce sujet, je change ma réponse en:

static String join( List<String> list , String replacement  ) {
    StringBuilder b = new StringBuilder();
    for( String item: list ) { 
        b.append( replacement ).append( item );
    }
    return b.toString().substring( replacement.length() );
}

Ce qui ressemble assez à la question d'origine.

Donc, si vous n'avez pas envie d'ajouter le pot entier à votre projet, vous pouvez l'utiliser.

Je pense qu'il n'y a rien de mal avec votre code d'origine. En fait, l'alternative que tout le monde suggère est presque la même (bien qu'elle fasse un certain nombre de validations supplémentaires)

Le voici, avec la licence Apache 2.0.

public static String join(Iterator iterator, String separator) {
    // handle null, zero and one elements before building a buffer
    if (iterator == null) {
        return null;
    }
    if (!iterator.hasNext()) {
        return EMPTY;
    }
    Object first = iterator.next();
    if (!iterator.hasNext()) {
        return ObjectUtils.toString(first);
    }

    // two or more elements
    StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small
    if (first != null) {
        buf.append(first);
    }

    while (iterator.hasNext()) {
        if (separator != null) {
            buf.append(separator);
        }
        Object obj = iterator.next();
        if (obj != null) {
            buf.append(obj);
        }
    }
    return buf.toString();
}

Maintenant, nous savons, merci open source

L'API Guava de Google a également .join (), bien que (comme cela devrait être évident avec les autres réponses), Apache Commons soit à peu près la norme ici.

Java 8 apporte le

Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

, c'est-à-dire nullsafe en utilisant prefix + suffixdes valeurs nulles.

Il peut être utilisé de la manière suivante:

String s = stringList.stream().collect(Collectors.joining(" and ", "prefix_", "_suffix"))

La Collectors.joining(CharSequence delimiter)méthode appelle simplement en joining(delimiter, "", "")interne.

Vous pouvez l'utiliser à partir de StringUtils de Spring Framework. Je sais qu'il a déjà été mentionné, mais vous pouvez réellement prendre ce code et cela fonctionne immédiatement, sans avoir besoin de Spring pour cela.

// from https://github.com/spring-projects/spring-framework/blob/master/spring-core/src/main/java/org/springframework/util/StringUtils.java

/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
public class StringUtils {
    public static String collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix) {
        if(coll == null || coll.isEmpty()) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        Iterator<?> it = coll.iterator();
        while (it.hasNext()) {
            sb.append(prefix).append(it.next()).append(suffix);
            if (it.hasNext()) {
                sb.append(delim);
            }
        }
        return sb.toString();
    }
}

Essaye ça:

java.util.Arrays.toString(anArray).replaceAll(", ", ",")
                .replaceFirst("^\\[","").replaceFirst("\\]$","");