Quelle est la meilleure façon de créer une chaîne d'éléments délimités en Java?

Lorsque je travaillais dans une application Java, j'ai récemment dû assembler une liste de valeurs délimitées par des virgules pour passer à un autre service Web sans savoir combien d'éléments il y aurait à l'avance. Le mieux que j'ai pu trouver du haut de ma tête était quelque chose comme ça:

public String appendWithDelimiter( String original, String addition, String delimiter ) {
    if ( original.equals( "" ) ) {
        return addition;
    } else {
        return original + delimiter + addition;
    }
}

String parameterString = "";
if ( condition ) parameterString = appendWithDelimiter( parameterString, "elementName", "," );
if ( anotherCondition ) parameterString = appendWithDelimiter( parameterString, "anotherElementName", "," );

Je me rends compte que ce n'est pas particulièrement efficace, car il y a des chaînes en cours de création partout, mais j'allais plus pour la clarté que l'optimisation.

Dans Ruby, je peux faire quelque chose comme ça à la place, ce qui est beaucoup plus élégant:

parameterArray = [];
parameterArray << "elementName" if condition;
parameterArray << "anotherElementName" if anotherCondition;
parameterString = parameterArray.join(",");

Mais comme Java n'a pas de commande join, je n'ai rien trouvé d'équivalent.

Alors, quelle est la meilleure façon de le faire en Java?

Pré Java 8:

Apache's commons lang est votre ami ici - il fournit une méthode de jointure très similaire à celle à laquelle vous faites référence dans Ruby:

StringUtils.join(java.lang.Iterable,char)

Java 8:

Java 8 permet de rejoindre dès la sortie de la boîte via StringJoineret String.join(). Les extraits ci-dessous montrent comment vous pouvez les utiliser:

StringJoiner

StringJoiner joiner = new StringJoiner(",");
joiner.add("01").add("02").add("03");
String joinedString = joiner.toString(); // "01,02,03"

String.join(CharSequence delimiter, CharSequence... elements))

String joinedString = String.join(" - ", "04", "05", "06"); // "04 - 05 - 06"

String.join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

List<String> strings = new LinkedList<>();
strings.add("Java");strings.add("is");
strings.add("cool");
String message = String.join(" ", strings);
//message returned is: "Java is cool"

Vous pouvez écrire une petite méthode utilitaire de style jointure qui fonctionne sur java.util.Lists

public static String join(List<String> list, String delim) {

    StringBuilder sb = new StringBuilder();

    String loopDelim = "";

    for(String s : list) {

        sb.append(loopDelim);
        sb.append(s);            

        loopDelim = delim;
    }

    return sb.toString();
}

Ensuite, utilisez-le comme ceci:

    List<String> list = new ArrayList<String>();

    if( condition )        list.add("elementName");
    if( anotherCondition ) list.add("anotherElementName");

    join(list, ",");

Dans le cas d'Android, la classe StringUtils de commons n'est pas disponible, donc pour cela j'ai utilisé

android.text.TextUtils.join(CharSequence delimiter, Iterable tokens)

http://developer.android.com/reference/android/text/TextUtils.html

La bibliothèque Google de Guava a com.google.common.base.Joiner classe qui aide à résoudre ces tâches.

Échantillons:

"My pets are: " + Joiner.on(", ").join(Arrays.asList("rabbit", "parrot", "dog")); 
// returns "My pets are: rabbit, parrot, dog"

Joiner.on(" AND ").join(Arrays.asList("field1=1" , "field2=2", "field3=3"));
// returns "field1=1 AND field2=2 AND field3=3"

Joiner.on(",").skipNulls().join(Arrays.asList("London", "Moscow", null, "New York", null, "Paris"));
// returns "London,Moscow,New York,Paris"

Joiner.on(", ").useForNull("Team held a draw").join(Arrays.asList("FC Barcelona", "FC Bayern", null, null, "Chelsea FC", "AC Milan"));
// returns "FC Barcelona, FC Bayern, Team held a draw, Team held a draw, Chelsea FC, AC Milan"

Voici un article sur les utilitaires de chaîne de Guava .

Dans Java 8, vous pouvez utiliser String.join():

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

Jetez également un œil à cette réponse pour un exemple d'API Stream.

Vous pouvez le généraliser, mais il n'y a pas de jointure en Java, comme vous le dites bien.

Cela pourrait mieux fonctionner.

public static String join(Iterable<? extends CharSequence> s, String delimiter) {
    Iterator<? extends CharSequence> iter = s.iterator();
    if (!iter.hasNext()) return "";
    StringBuilder buffer = new StringBuilder(iter.next());
    while (iter.hasNext()) buffer.append(delimiter).append(iter.next());
    return buffer.toString();
}

dans Java 8, vous pouvez faire ceci comme:

list.stream().map(Object::toString)
        .collect(Collectors.joining(delimiter));

si la liste a des valeurs nulles, vous pouvez utiliser:

list.stream().map(String::valueOf)
        .collect(Collectors.joining(delimiter))

il prend également en charge le préfixe et le suffixe:

list.stream().map(String::valueOf)
        .collect(Collectors.joining(delimiter, prefix, suffix));

Utilisez une approche basée sur java.lang.StringBuilder! ("Une séquence de caractères modifiable.")

Comme vous l'avez mentionné, toutes ces concaténations de chaînes créent des chaînes partout. StringBuilderne fera pas ça.

Pourquoi StringBuilderau lieu de StringBuffer? Du StringBuilderjavadoc:

Dans la mesure du possible, il est recommandé d'utiliser cette classe de préférence à StringBuffer car elle sera plus rapide dans la plupart des implémentations.

J'utiliserais Google Collections. Il y a une belle installation Join.
http://google-collections.googlecode.com/svn/trunk/javadoc/index.html?com/google/common/base/Join.html

Mais si je voulais l'écrire moi-même,

package util;

import java.util.ArrayList;
import java.util.Iterable;
import java.util.Collections;
import java.util.Iterator;

public class Utils {
    // accept a collection of objects, since all objects have toString()
    public static String join(String delimiter, Iterable<? extends Object> objs) {
        if (objs.isEmpty()) {
            return "";
        }
        Iterator<? extends Object> iter = objs.iterator();
        StringBuilder buffer = new StringBuilder();
        buffer.append(iter.next());
        while (iter.hasNext()) {
            buffer.append(delimiter).append(iter.next());
        }
        return buffer.toString();
    }

    // for convenience
    public static String join(String delimiter, Object... objs) {
        ArrayList<Object> list = new ArrayList<Object>();
        Collections.addAll(list, objs);
        return join(delimiter, list);
    }
}

Je pense que cela fonctionne mieux avec une collection d'objets, car maintenant vous n'avez plus besoin de convertir vos objets en chaînes avant de les rejoindre.

La classe Apache commons StringUtils a une méthode de jointure.

Java 8

stringCollection.stream().collect(Collectors.joining(", "));

Vous pouvez utiliser le StringBuildertype Java pour cela. Il y en a aussi StringBuffer, mais il contient une logique de sécurité de thread supplémentaire qui est souvent inutile.

Et un minimum (si vous ne voulez pas inclure Apache Commons ou Gauva dans les dépendances du projet juste pour joindre des chaînes)

/**
 *
 * @param delim : String that should be kept in between the parts
 * @param parts : parts that needs to be joined
 * @return  a String that's formed by joining the parts
 */
private static final String join(String delim, String... parts) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < parts.length - 1; i++) {
        builder.append(parts[i]).append(delim);
    }
    if(parts.length > 0){
        builder.append(parts[parts.length - 1]);
    }
    return builder.toString();
}

Utilisez StringBuilder et la classe Separator

StringBuilder buf = new StringBuilder();
Separator sep = new Separator(", ");
for (String each : list) {
    buf.append(sep).append(each);
}

Le séparateur encapsule un délimiteur. Le délimiteur est retourné par la toStringméthode du séparateur , sauf lors du premier appel qui retourne la chaîne vide!

Code source de la classe Separator

public class Separator {

    private boolean skipFirst;
    private final String value;

    public Separator() {
        this(", ");
    }

    public Separator(String value) {
        this.value = value;
        this.skipFirst = true;
    }

    public void reset() {
        skipFirst = true;
    }

    public String toString() {
        String sep = skipFirst ? "" : value;
        skipFirst = false;
        return sep;
    }

}

Pourquoi ne pas écrire votre propre méthode join ()? Il prendrait comme collection de paramètres des chaînes et une chaîne de délimitation. Dans la méthode, parcourez la collection et générez votre résultat dans un StringBuffer.

Si vous utilisez Spring MVC, vous pouvez essayer les étapes suivantes.

import org.springframework.util.StringUtils;

List<String> groupIds = new List<String>;   
groupIds.add("a");    
groupIds.add("b");    
groupIds.add("c");

String csv = StringUtils.arrayToCommaDelimitedString(groupIds.toArray());

Il en résultera a,b,c

Si vous utilisez des collections Eclipse , vous pouvez utiliser makeString()ou appendString().

makeString()renvoie une Stringreprésentation, similaire àtoString() .

Il a trois formes

• makeString(start, separator, end)
• makeString(separator) valeurs par défaut de début et de fin pour les chaînes vides
• makeString() par défaut, le séparateur est ", " (virgule et espace)

Exemple de code:

MutableList<Integer> list = FastList.newListWith(1, 2, 3);
assertEquals("[1/2/3]", list.makeString("[", "/", "]"));
assertEquals("1/2/3", list.makeString("/"));
assertEquals("1, 2, 3", list.makeString());
assertEquals(list.toString(), list.makeString("[", ", ", "]"));

appendString()est similaire à makeString(), mais il s'ajoute à un Appendable(comme StringBuilder) et l'est void. Il a les trois mêmes formes, avec un premier argument supplémentaire, l'Appendable.

MutableList<Integer> list = FastList.newListWith(1, 2, 3);
Appendable appendable = new StringBuilder();
list.appendString(appendable, "[", "/", "]");
assertEquals("[1/2/3]", appendable.toString());

Si vous ne pouvez pas convertir votre collection en type de collections Eclipse, adaptez-la simplement avec l'adaptateur approprié.

List<Object> list = ...;
ListAdapter.adapt(list).makeString(",");

Remarque: je suis un committer pour les collections Eclipse.

Java 8 Native Type

List<Integer> example;
example.add(1);
example.add(2);
example.add(3);
...
example.stream().collect(Collectors.joining(","));

Objet personnalisé Java 8:

List<Person> person;
...
person.stream().map(Person::getAge).collect(Collectors.joining(","));

Vous devriez probablement utiliser un StringBuilderavec la appendméthode pour construire votre résultat, mais sinon c'est aussi une bonne solution que Java a à offrir.

Pourquoi ne faites-vous pas en Java la même chose que vous faites en ruby, c'est-à-dire créer la chaîne séparée par un délimiteur seulement après avoir ajouté toutes les pièces au tableau?

ArrayList<String> parms = new ArrayList<String>();
if (someCondition) parms.add("someString");
if (anotherCondition) parms.add("someOtherString");
// ...
String sep = ""; StringBuffer b = new StringBuffer();
for (String p: parms) {
    b.append(sep);
    b.append(p);
    sep = "yourDelimiter";
}

Vous voudrez peut-être déplacer cela pour la boucle dans une méthode d'assistance distincte, et utiliser également StringBuilder au lieu de StringBuffer ...

Edit : correction de l'ordre des ajouts.

Avec les arguments de variable Java 5, vous n'avez donc pas à remplir toutes vos chaînes dans une collection ou un tableau explicitement:

import junit.framework.Assert;
import org.junit.Test;

public class StringUtil
{
    public static String join(String delim, String... strings)
    {
        StringBuilder builder = new StringBuilder();

        if (strings != null)
        {
            for (String str : strings)
            {
                if (builder.length() > 0)
                {
                    builder.append(delim).append(" ");
                }
                builder.append(str);
            }
        }           
        return builder.toString();
    }
    @Test
    public void joinTest()
    {
        Assert.assertEquals("", StringUtil.join(",", null));
        Assert.assertEquals("", StringUtil.join(",", ""));
        Assert.assertEquals("", StringUtil.join(",", new String[0]));
        Assert.assertEquals("test", StringUtil.join(",", "test"));
        Assert.assertEquals("foo, bar", StringUtil.join(",", "foo", "bar"));
        Assert.assertEquals("foo, bar, x", StringUtil.join(",", "foo", "bar", "x"));
    }
}

Pour ceux qui sont dans un contexte Spring, leur classe StringUtils est également utile:

Il existe de nombreux raccourcis utiles tels que:

• collectionToCommaDelimitedString (Collection coll)
• collectionToDelimitedString (Collection coll, String delim)
• arrayToDelimitedString (Object [] arr, String delim)

et plein d'autres.

Cela peut être utile si vous n'utilisez pas déjà Java 8 et que vous êtes déjà dans un contexte Spring.

Je le préfère contre Apache Commons (bien que très bon aussi) pour le support de Collection qui est plus facile comme ceci:

// Encoding Set<String> to String delimited 
String asString = org.springframework.util.StringUtils.collectionToDelimitedString(codes, ";");

// Decoding String delimited to Set
Set<String> collection = org.springframework.util.StringUtils.commaDelimitedListToSet(asString);

Vous pouvez essayer quelque chose comme ceci:

StringBuilder sb = new StringBuilder();
if (condition) { sb.append("elementName").append(","); }
if (anotherCondition) { sb.append("anotherElementName").append(","); }
String parameterString = sb.toString();

Donc, fondamentalement, quelque chose comme ça:

public static String appendWithDelimiter(String original, String addition, String delimiter) {

if (original.equals("")) {
    return addition;
} else {
    StringBuilder sb = new StringBuilder(original.length() + addition.length() + delimiter.length());
        sb.append(original);
        sb.append(delimiter);
        sb.append(addition);
        return sb.toString();
    }
}

Je ne sais pas si c'est vraiment mieux, mais au moins, il utilise StringBuilder, qui peut être légèrement plus efficace.

Vous trouverez ci-dessous une approche plus générique si vous pouvez créer la liste des paramètres AVANT d'effectuer une délimitation de paramètre.

// Answers real question
public String appendWithDelimiters(String delimiter, String original, String addition) {
    StringBuilder sb = new StringBuilder(original);
    if(sb.length()!=0) {
        sb.append(delimiter).append(addition);
    } else {
        sb.append(addition);
    }
    return sb.toString();
}


// A more generic case.
// ... means a list of indeterminate length of Strings.
public String appendWithDelimitersGeneric(String delimiter, String... strings) {
    StringBuilder sb = new StringBuilder();
    for (String string : strings) {
        if(sb.length()!=0) {
            sb.append(delimiter).append(string);
        } else {
            sb.append(string);
        }
    }

    return sb.toString();
}

public void testAppendWithDelimiters() {
    String string = appendWithDelimitersGeneric(",", "string1", "string2", "string3");
}

Votre approche n'est pas trop mauvaise, mais vous devez utiliser un StringBuffer au lieu d'utiliser le signe +. Le + a le gros inconvénient qu'une nouvelle instance de chaîne est créée pour chaque opération. Plus votre chaîne est longue, plus les frais généraux sont importants. Donc, utiliser un StringBuffer devrait être le moyen le plus rapide:

public StringBuffer appendWithDelimiter( StringBuffer original, String addition, String delimiter ) {
        if ( original == null ) {
                StringBuffer buffer = new StringBuffer();
                buffer.append(addition);
                return buffer;
        } else {
                buffer.append(delimiter);
                buffer.append(addition);
                return original;
        }
}

Après avoir créé votre chaîne, appelez simplement toString () sur le StringBuffer retourné.

Au lieu d'utiliser la concaténation de chaînes, vous devez utiliser StringBuilder si votre code n'est pas enfilé et StringBuffer si c'est le cas.

Vous rendez cela un peu plus compliqué qu'il ne doit l'être. Commençons par la fin de votre exemple:

String parameterString = "";
if ( condition ) parameterString = appendWithDelimiter( parameterString, "elementName", "," );
if ( anotherCondition ) parameterString = appendWithDelimiter( parameterString, "anotherElementName", "," );

Avec le petit changement de l'utilisation d'un StringBuilder au lieu d'une chaîne, cela devient:

StringBuilder parameterString = new StringBuilder();
if (condition) parameterString.append("elementName").append(",");
if (anotherCondition) parameterString.append("anotherElementName").append(",");
...

Lorsque vous avez terminé (je suppose que vous devez également vérifier quelques autres conditions), assurez-vous de supprimer la virgule de queue avec une commande comme celle-ci:

if (parameterString.length() > 0) 
    parameterString.deleteCharAt(parameterString.length() - 1);

Et enfin, obtenez la chaîne que vous voulez avec

parameterString.toString();

Vous pouvez également remplacer le "," dans le deuxième appel à ajouter par une chaîne de délimitation générique qui peut être définie sur n'importe quoi. Si vous avez une liste de choses que vous savez que vous devez ajouter (sans condition), vous pouvez mettre ce code dans une méthode qui prend une liste de chaînes.

//Note: if you have access to Java5+, 
//use StringBuilder in preference to StringBuffer.  
//All that has to be replaced is the class name.  
//StringBuffer will work in Java 1.4, though.

appendWithDelimiter( StringBuffer buffer, String addition, 
    String delimiter ) {
    if ( buffer.length() == 0) {
        buffer.append(addition);
    } else {
        buffer.append(delimiter);
        buffer.append(addition);
    }
}


StringBuffer parameterBuffer = new StringBuffer();
if ( condition ) { 
    appendWithDelimiter(parameterBuffer, "elementName", "," );
}
if ( anotherCondition ) {
    appendWithDelimiter(parameterBuffer, "anotherElementName", "," );
}

//Finally, to return a string representation, call toString() when returning.
return parameterBuffer.toString(); 

Donc, quelques choses que vous pourriez faire pour avoir l'impression que vous cherchez:

1) Étendre la classe List - et y ajouter la méthode join. La méthode join ferait simplement le travail de concaténation et d'ajout du délimiteur (qui pourrait être un paramètre de la méthode join)

2) Il semble que Java 7 va ajouter des méthodes d'extension à java - ce qui vous permet simplement d'attacher une méthode spécifique à une classe: vous pouvez donc écrire cette méthode de jointure et l'ajouter en tant que méthode d'extension à List ou même à Collection.

La solution 1 est probablement la seule réaliste à l'heure actuelle, bien que Java 7 ne soit pas encore sorti :) Mais cela devrait très bien fonctionner.

Pour utiliser les deux, il vous suffit d'ajouter tous vos éléments à la liste ou à la collection comme d'habitude, puis d'appeler la nouvelle méthode personnalisée pour les «joindre».