Der schnellste Weg, um den Inhalt von Set <String> in einen einzelnen String mit durch ein Leerzeichen getrennten Wörtern zu setzen?

Ich habe ein paar Set<String>s und möchte jedes davon in ein einzelnes verwandeln, Stringwobei jedes Element des Originals Setdurch ein Leerzeichen "" getrennt ist. Ein naiver erster Ansatz macht es so

Set<String> set_1;
Set<String> set_2;

StringBuilder builder = new StringBuilder();
for (String str : set_1) {
  builder.append(str).append(" ");
}

this.string_1 = builder.toString();

builder = new StringBuilder();
for (String str : set_2) {
  builder.append(str).append(" ");
}

this.string_2 = builder.toString();

Kann sich jemand einen schnelleren, schöneren oder effizienteren Weg vorstellen, dies zu tun?

Mit commons / lang können Sie dies mit StringUtils.join tun :

String str_1 = StringUtils.join(set_1, " ");

Das kann man der Kürze halber nicht wirklich übertreffen.

Aktualisieren:

Wenn ich diese Antwort noch einmal lese, würde ich jetzt die andere Antwort in Bezug auf Guavas Tischler vorziehen . Tatsächlich gehe ich heutzutage nicht in die Nähe von Apache Commons.

Ein weiteres Update:

Java 8 führte die Methode ein String.join()

String joined = String.join(",", set);

Dies ist zwar nicht so flexibel wie die Guava-Version, aber praktisch, wenn Sie die Guava-Bibliothek nicht in Ihrem Klassenpfad haben.

Wenn Sie Java 8 verwenden, können Sie das native verwenden

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

Methode:

Gibt eine neue Stringzusammengesetzte Kopie der CharSequenceElemente zurück, die zusammen mit einer Kopie des angegebenen Trennzeichens verbunden sind. Zum Beispiel:

 Set<String> strings = new LinkedHashSet<>();
 strings.add("Java"); strings.add("is");
 strings.add("very"); strings.add("cool");
 String message = String.join("-", strings);
 //message returned is: "Java-is-very-cool"

SetGeräte Iterable, also einfach verwenden:

String.join(" ", set_1);

Als Kontrapunkt zu Seanizers Antwort auf Commons-Lang würden Sie Joiner verwenden , wenn Sie die Guava-Bibliotheken von Google verwenden (die ich in vielerlei Hinsicht als "Nachfolger" von Commons-Lang betrachten würde) :

Joiner.on(" ").join(set_1);

mit dem Vorteil einiger Hilfsmethoden, um Dinge wie:

Joiner.on(" ").skipNulls().join(set_1);
// If 2nd item was null, would produce "1, 3"

oder

Joiner.on(" ").useForNull("<unknown>").join(set_1);
// If 2nd item was null, would produce "1, <unknown>, 3"

Es unterstützt auch das direkte Anhängen an StringBuilders and Writers und andere solche Feinheiten.

Ich habe die StringUtil-Bibliothek nicht verfügbar (ich habe keine andere Wahl), also habe ich mir mit Standard-Java diese ausgedacht.

Wenn Sie sicher sind, dass Ihre festgelegten Daten keine Kommas oder eckigen Klammern enthalten, können Sie Folgendes verwenden:

mySet.toString().replaceAll("\\[|\\]","").replaceAll(","," ");

Eine Menge von "a", "b", "c" wird über .toString () in eine Zeichenfolge "[a, b, c]" konvertiert.

Ersetzen Sie dann die zusätzliche Interpunktion nach Bedarf.

Schmutz.

Vielleicht eine kürzere Lösung:

public String test78 (Set<String> set) {
    return set
        .stream()
        .collect(Collectors.joining(" "));
}

oder

public String test77 (Set<String> set) {
    return set
        .stream()
        .reduce("", (a,b)->(a + " " + b));
}

aber einheimisch, definitiv schneller

public String test76 (Set<String> set) {
    return String.join(" ", set);
}

Ich benutze diese Methode:

public static String join(Set<String> set, String sep) {
    String result = null;
    if(set != null) {
        StringBuilder sb = new StringBuilder();
        Iterator<String> it = set.iterator();
        if(it.hasNext()) {
            sb.append(it.next());
        }
        while(it.hasNext()) {
            sb.append(sep).append(it.next());
        }
        result = sb.toString();
    }
    return result;
}

Ich bin verwirrt über die Codereplikation. Warum nicht eine Funktion berücksichtigen, die einen Satz benötigt und eine Zeichenfolge zurückgibt?

Abgesehen davon bin ich mir nicht sicher, ob Sie noch viel tun können, außer vielleicht dem Stringbuilder einen Hinweis auf die erwartete Kapazität zu geben (wenn Sie diese anhand der festgelegten Größe und der angemessenen Erwartung der Stringlänge berechnen können).

Auch dafür gibt es Bibliotheksfunktionen, aber ich bezweifle, dass sie wesentlich effizienter sind.

Dies kann erreicht werden, indem ein Stream aus dem Satz erstellt und die Elemente dann mithilfe einer Reduzierungsoperation wie unten gezeigt kombiniert werden (weitere Informationen zu Java 8-Streams finden Sie hier ):

Optional<String> joinedString = set1.stream().reduce(new 
BinaryOperator<String>() {

     @Override
     public String apply(String t, String u) {

       return t + " " + u;
    }
});
return joinedString.orElse("");