Java: convertir List<String> pour une Chaîne de caractères

Avec Java 8, vous pouvez le faire sans aucun la troisième partie de la bibliothèque.

Si vous voulez vous joindre à une Collection de Chaînes, vous pouvez utiliser le nouveau Chaîne de caractères.join() méthode:

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 de Chaîne de caractères, vous pouvez utiliser le Flux de l'API avec le rejoindre le Collecteur:

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 StringJoiner classe peut également être utile.

Pas hors de la boîte, mais beaucoup de bibliothèques ont les mêmes:

Commons Lang:

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

Printemps:

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

Non, il n'y a pas une telle méthode de convenance dans la norme API Java.

Il n'est pas surprenant, Apache Commons fournit une telle chose dans leur StringUtils classe dans le cas où vous ne voulez pas écrire vous-même.

Avec java 8 collecteur, ce qui peut être fait avec le code suivant:

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

Aussi, la solution la plus simple en java 8:

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

ou

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

Code que vous avez est de bonne façon de le faire si vous voulez le faire à l'aide du JDK, sans les bibliothèques externes. Il n'est pas simple "one-liner" que vous pouvez utiliser dans le JDK.

Si vous pouvez utiliser des libs, je recommande que vous regardez dans les org.apache.commons.lang.StringUtils classe dans Apache Commons bibliothèque.

Un exemple d'utilisation:

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

Vous pouvez utiliser l'apache commons bibliothèque qui a un StringUtils classe et une méthode de participation.

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

À noter que le lien ci-dessus peuvent devenir obsolètes au fil du temps, dans ce cas, vous pouvez faire une recherche sur le web pour "apache commons StringUtils", qui devrait vous permettre de trouver la dernière version de référence.

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

Vous pouvez faire ceci:

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 un one-liner (seulement si vous ne voulez pas '[' et ']')

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

Espère que cette aide.

Vous pourriez vouloir essayer d'Apache Commons StringUtils méthode join:

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

J'ai trouvé que Apache StringUtils ramasse du jdk de mou 😉

Avec java 1.8 flux 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 "));

MODIFIER

Je remarque aussi la toString() sous-jacents au problème de mise en œuvre, et sur l'élément contenant le séparateur, mais j'ai pensé que j'étais paranoïaque.

Vu que j'ai deux commentaires à faire sur ce sujet, je vais changer ma réponse:

    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() );
    }

Qui ressemble assez à la question d'origine.

Donc, si vous ne vous sentez pas comme l'ajout de tout le pot à votre projet, vous pouvez utiliser ce.

Je pense qu'il n'y a rien de mal avec votre code d'origine. En fait, l'alternative que tout le monde est ce qui suggère ressemble presque la même ( même si il fait un certain nombre d'autres validations )

Ici, il est, avec le 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();
   }

Nous savons maintenant, je vous remercie open source

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

//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();
    }
}