Qual é a melhor maneira de criar uma sequência de itens delimitados em Java?

Enquanto trabalhava em um aplicativo Java, recentemente precisei montar uma lista de valores delimitada por vírgulas para passar para outro serviço da web sem saber quantos elementos haveria com antecedência. O melhor que eu conseguia pensar era algo assim:

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", "," );

Sei que isso não é particularmente eficiente, já que existem strings sendo criadas em todo o lugar, mas eu estava buscando mais clareza do que otimização.

Em Ruby, eu posso fazer algo assim, que parece muito mais elegante:

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

Mas como o Java não possui um comando join, não consegui descobrir nada equivalente.

Então, qual é a melhor maneira de fazer isso em Java?

Antes do Java 8:

O commons lang do Apache é seu amigo aqui - ele fornece um método de junção muito semelhante ao que você se refere no Ruby:

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

Java 8:

O Java 8 fornece a junção imediata através de StringJoinere String.join(). Os trechos abaixo mostram como você pode usá-los:

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"

Você pode escrever um pequeno método utilitário de estilo de junção que funciona em 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();
}

Em seguida, use-o assim:

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

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

    join(list, ",");

No caso do Android, a classe StringUtils de commons não está disponível, então, para isso, usei

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

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

A biblioteca Guava do Google possui a classe com.google.common.base.Joiner, que ajuda a resolver essas tarefas.

Amostras:

"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"

Aqui está um artigo sobre os utilitários de string do Guava .

No Java 8, você pode usar String.join():

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

Veja também esta resposta para obter um exemplo da API de fluxo.

Você pode generalizá-lo, mas não há junção em Java, como você bem diz.

Isso pode funcionar melhor.

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

No Java 8, você pode fazer o seguinte:

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

se a lista tiver nulos, você pode usar:

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

também suporta prefixo e sufixo:

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

Use uma abordagem baseada em java.lang.StringBuilder! ("Uma sequência mutável de caracteres.")

Como você mencionou, todas essas concatenações de strings estão criando Strings por todo o lado. StringBuildernão vai fazer isso.

Por que ao StringBuilderinvés de StringBuffer? Do StringBuilderjavadoc:

Sempre que possível, é recomendável que essa classe seja usada preferencialmente ao StringBuffer, pois será mais rápida na maioria das implementações.

Eu usaria o Google Collections. Há uma boa instalação de associação.
http://google-collections.googlecode.com/svn/trunk/javadoc/index.html?com/google/common/base/Join.html

Mas se eu quisesse escrever sozinho,

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

Eu acho que funciona melhor com uma coleção de objetos, já que agora você não precisa converter seus objetos em seqüências de caracteres antes de se juntar a eles.

A classe StringUtils do Apache commons possui um método de junção.

Java 8

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

Você pode usar o StringBuildertipo de Java para isso. Também existe StringBuffer, mas contém uma lógica de segurança de thread extra que geralmente é desnecessária.

E um mínimo (se você não quiser incluir o Apache Commons ou o Gauva nas dependências do projeto apenas para unir cadeias)

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

Use StringBuilder e classe Separator

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

O separador envolve um delimitador. O delimitador é retornado pelo toStringmétodo Separator , a menos que na primeira chamada que retorne a string vazia!

Código fonte da 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;
    }

}

Por que não escrever seu próprio método join ()? Seria tomada como parâmetros a coleção de Strings e um delimitador String. Dentro do método, itere sobre a coleção e crie seu resultado em um StringBuffer.

Se você estiver usando o Spring MVC, poderá tentar as seguintes etapas.

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

Isso resultará em a,b,c

Se você estiver usando o Eclipse Collections , poderá usar makeString()ou appendString().

makeString()retorna uma Stringrepresentação, semelhante a toString().

Tem três formas

• makeString(start, separator, end)
• makeString(separator) o padrão inicia e termina com cadeias vazias
• makeString()padroniza o separador para ", "(vírgula e espaço)

Exemplo de código:

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()é semelhante a makeString(), mas anexa a um Appendable(como StringBuilder) e é void. Ele tem as mesmas três formas, com um primeiro argumento adicional, o Appendable.

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

Se você não pode converter sua coleção em um tipo de Coleções Eclipse, basta adaptá-la com o adaptador relevante.

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

Nota: Sou responsável por coleções do Eclipse.

Tipo nativo Java 8

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

Objeto personalizado do Java 8:

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

Você provavelmente deve usar a StringBuildercom o appendmétodo para construir seu resultado, mas, caso contrário, essa é uma solução tão boa quanto o Java tem a oferecer.

Por que você não faz em Java o mesmo que está fazendo em ruby, que é criar a sequência separada por delimitador somente depois de adicionar todas as partes à matriz?

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";
}

Você pode mover esse loop for em um método auxiliar separado e também usar StringBuilder em vez de StringBuffer ...

Editar : corrigida a ordem dos anexos.

Com o Java 5 args variáveis, você não precisa inserir todas as suas strings em uma coleção ou matriz explicitamente:

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

Para aqueles que estão em um contexto Spring, sua classe StringUtils também é útil:

Existem muitos atalhos úteis, como:

• collectionToCommaDelimitedString (coleção Coll)
• collectionToDelimitedString (coleção Coll, delim String)
• arrayToDelimitedString (Object [] arr, Delim String)

e muitos outros.

Isso pode ser útil se você ainda não estiver usando o Java 8 e já estiver em um contexto do Spring.

Eu prefiro o Apache Commons (embora seja muito bom também) pelo suporte ao Collection, que é mais fácil assim:

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

Você pode tentar algo como isto:

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

Então, basicamente, algo como isto:

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

Não sei se isso realmente é melhor, mas pelo menos está usando o StringBuilder, que pode ser um pouco mais eficiente.

Abaixo, há uma abordagem mais genérica se você puder criar a lista de parâmetros ANTES de fazer qualquer delimitação de parâmetro.

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

Sua abordagem não é muito ruim, mas você deve usar um StringBuffer em vez de usar o sinal +. O + tem a grande desvantagem de que uma nova instância String está sendo criada para cada operação única. Quanto mais tempo sua corda ficar, maior será a sobrecarga. Portanto, usar um StringBuffer deve ser a maneira mais rápida:

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

Depois de terminar de criar sua string, basta chamar toString () no StringBuffer retornado.

Em vez de usar a concatenação de strings, você deve usar StringBuilder se seu código não estiver em thread e StringBuffer, se estiver.

Você está tornando isso um pouco mais complicado do que precisa ser. Vamos começar com o fim do seu exemplo:

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

Com a pequena alteração do uso de um StringBuilder em vez de um String, isso se torna:

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

Quando terminar (suponho que você também precise verificar algumas outras condições), remova a vírgula final com um comando como este:

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

E, finalmente, obtenha a sequência desejada

parameterString.toString();

Você também pode substituir o "," na segunda chamada para anexar com uma cadeia de caracteres delimitadora genérica que pode ser definida como qualquer coisa. Se você tiver uma lista de itens que você precisa anexar (não condicionalmente), poderá colocar esse código dentro de um método que faça uma lista de strings.

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

Então, você pode fazer algumas coisas para ter a sensação de que está procurando:

1) Estender a classe List - e adicione o método join a ele. O método join simplesmente faria o trabalho de concatenar e adicionar o delimitador (que poderia ser um parâmetro para o método join)

2) Parece que o Java 7 adicionará métodos de extensão ao java - o que permite anexar um método específico a uma classe: para que você possa escrever esse método join e adicioná-lo como um método de extensão à List ou até ao Coleção.

A solução 1 é provavelmente a única realista, agora, já que o Java 7 ainda não foi lançado :) Mas deve funcionar muito bem.

Para usar os dois, basta adicionar todos os seus itens à Lista ou Coleção, como de costume, e chamar o novo método personalizado para 'juntá-los'.