Wie kann man in Java am besten eine Zeichenkette mit abgegrenzten Elementen erstellen?

Question

Bei der Arbeit in einer Java-Anwendung musste ich kürzlich eine durch Kommata getrennte Liste von Werten zusammenstellen, die ich an einen anderen Webdienst weitergeben wollte, ohne im Voraus zu wissen, wie viele Elemente es sein würden. Das Beste, was mir auf Anhieb einfiel, war so etwas wie dieses:

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

Mir ist klar, dass dies nicht besonders effizient ist, da überall Zeichenketten erstellt werden, aber mir ging es mehr um Klarheit als um Optimierung.

In Ruby kann ich stattdessen etwas Ähnliches machen, was sich viel eleganter anfühlt:

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

Aber da Java keinen Join-Befehl hat, konnte ich nichts Vergleichbares finden.

Wie lässt sich dies in Java am besten bewerkstelligen?

Answer 1

Ich weiß nicht, ob dies wirklich besser ist, aber zumindest ist es mit StringBuilder, die etwas effizienter sein kann.

Nachfolgend finden Sie einen allgemeineren Ansatz, wenn Sie die Liste der Parameter erstellen können, BEVOR Sie eine Parameterabgrenzung vornehmen.

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

Answer 2

Im Grunde also so etwas wie das hier:

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

Answer 3

Fixe Antwort Rob Dickerson.

Es ist einfacher zu benutzen:

public static String join(String delimiter, String... values)
{
    StringBuilder stringBuilder = new StringBuilder();

    for (String value : values)
    {
        stringBuilder.append(value);
        stringBuilder.append(delimiter);
    }

    String result = stringBuilder.toString();

    return result.isEmpty() ? result : result.substring(0, result.length() - 1);
}

Answer 4

Ich persönlich verwende häufig die folgende einfache Lösung für Protokollierungszwecke:

List lst = Arrays.asList("ab", "bc", "cd");
String str = lst.toString().replaceAll("[\\[\\]]", "");

Answer 5

Sie können es so versuchen:

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