Java: Funktion für Arrays wie PHPs join ()?

Ich möchte mich String[]mit einem Klebeband verbinden. Gibt es dafür eine Funktion?

Ab Java8 ist die Verwendung möglich String.join().

String.join(", ", new String[]{"Hello", "World", "!"})

Erzeugt:

Hello, World, !

Andernfalls verfügt Apache Commons Lang über eine StringUtilsKlasse mit einer joinFunktion, die Arrays zu a zusammenfügt String.

Beispielsweise:

StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")

Erzeugt Folgendes String:

Hello, World, !

Wenn Sie nach dem suchen, was Sie in Android verwenden können, ist es:

String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)

beispielsweise:

String joined = TextUtils.join(";", MyStringArray);

In Java 8 können Sie verwenden

1) Stream-API:

String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));

2) Neue String.join-Methode: https://stackoverflow.com/a/21756398/466677

3) java.util.StringJoiner-Klasse: http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html

Sie könnten eine solche Funktion leicht in etwa zehn Codezeilen schreiben:

String combine(String[] s, String glue)
{
  int k = s.length;
  if ( k == 0 )
  {
    return null;
  }
  StringBuilder out = new StringBuilder();
  out.append( s[0] );
  for ( int x=1; x < k; ++x )
  {
    out.append(glue).append(s[x]);
  }
  return out.toString();
}

Ein kleiner Mod anstelle von substring ():

//join(String array,delimiter)
public static String join(String r[],String d)
{
        if (r.length == 0) return "";
        StringBuilder sb = new StringBuilder();
        int i;
        for(i=0;i<r.length-1;i++){
            sb.append(r[i]);
            sb.append(d);
        }
        sb.append(r[i]);
        return sb.toString();
}

Wie bei vielen Fragen in letzter Zeit hilft Java 8:

Java 8 hat eine neue statische Methode hinzugefügt, java.lang.Stringdie genau das tut, was Sie wollen:

public static String join(CharSequence delimeter, CharSequence... elements);

Es benutzen:

String s = String.join(", ", new String[] {"Hello", "World", "!"});

Ergebnisse in:

"Hello, World, !"

Die Bibliothek von Google Guava verfügt ebenfalls über diese Funktion . Sie können das Beispiel String [] auch in der API sehen.

Achten Sie, wie bereits in der API beschrieben, auf die Unveränderlichkeit der Builder-Methoden.

Es kann eine Reihe von Objekten akzeptieren, sodass es in Ihrem Fall funktioniert. In meiner vorherigen Erfahrung habe ich versucht, mich einem Stapel anzuschließen, der iterierbar ist und gut funktioniert.

Probe von mir:

Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");

druckt aus: |i am a coder|

Gegeben:

String[] a = new String[] { "Hello", "World", "!" };

Dann als Alternative zu Coobirds Antwort, wo der Kleber "," ist:

Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")

Oder um mit einer anderen Zeichenfolge zu verketten, z. B. "& amp;".

Arrays.asList(a).toString().replaceAll(", ", " & ").replaceAll("^\\[|\\]$", "")

Dies funktioniert jedoch NUR, wenn Sie wissen, dass die Werte im Array oder in der Liste NICHT die Zeichenfolge "," enthalten.

Wenn Sie das Spring Framework verwenden , haben Sie die StringUtils- Klasse:

import static org.springframework.util.StringUtils.arrayToDelimitedString;

arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");

Nicht im Kern, nein. Eine Suche nach "Java Array Join String Glue" gibt Ihnen jedoch einige Code-Schnipsel, wie Sie dies erreichen können.

z.B

public static String join(Collection s, String delimiter) {
    StringBuffer buffer = new StringBuffer();
    Iterator iter = s.iterator();
    while (iter.hasNext()) {
        buffer.append(iter.next());
        if (iter.hasNext()) {
            buffer.append(delimiter);
        }
    }
    return buffer.toString();
}

Wenn Sie hier gelandet sind und nach einer schnellen Konvertierung von Array zu String suchen, versuchen Sie es mit Arrays.toString () .

Erstellt eine String-Darstellung des Object[]übergebenen. Das Ergebnis ist von Klammern ( "[]") umgeben. Jedes Element wird über das in einen String konvertiert String.valueOf(Object)und durch getrennt ", ". Wenn das Array ist null, "null"wird zurückgegeben.

Nur für die "Ich habe die kürzeste" Herausforderung, hier sind Minen;)

Iterativ:

public static String join(String s, Object... a) {
    StringBuilder o = new StringBuilder();
    for (Iterator<Object> i = Arrays.asList(a).iterator(); i.hasNext();)
        o.append(i.next()).append(i.hasNext() ? s : "");
    return o.toString();
}

Rekursiv:

public static String join(String s, Object... a) {
    return a.length == 0 ? "" : a[0] + (a.length == 1 ? "" : s + join(s, Arrays.copyOfRange(a, 1, a.length)));
}

Nichts eingebaut, von dem ich weiß.

Apache Commons Lang hat eine Klasse namens, StringUtilsdie viele Verknüpfungsfunktionen enthält.

So mache ich es.

private String join(String[] input, String delimiter)
{
    StringBuilder sb = new StringBuilder();
    for(String value : input)
    {
        sb.append(value);
        sb.append(delimiter);
    }
    int length = sb.length();
    if(length > 0)
    {
        // Remove the extra delimiter
        sb.setLength(length - delimiter.length());
    }
    return sb.toString();
}

Eine ähnliche Alternative

/**
 * @param delimiter 
 * @param inStr
 * @return String
 */
public static String join(String delimiter, String... inStr)
{
    StringBuilder sb = new StringBuilder();
    if (inStr.length > 0)
    {
        sb.append(inStr[0]);
        for (int i = 1; i < inStr.length; i++)
        {
            sb.append(delimiter);                   
            sb.append(inStr[i]);
        }
    }
    return sb.toString();
}

Mein Spin.

public static String join(Object[] objects, String delimiter) {
  if (objects.length == 0) {
    return "";
  }
  int capacityGuess = (objects.length * objects[0].toString().length())
      + ((objects.length - 1) * delimiter.length());
  StringBuilder ret = new StringBuilder(capacityGuess);
  ret.append(objects[0]);
  for (int i = 1; i < objects.length; i++) {
    ret.append(delimiter);
    ret.append(objects[i]);
  }
  return ret.toString();
}

public static String join(Object... objects) {
  return join(objects, "");
}

Gefällt dir mein 3-Zeilen-Weg nur mit den Methoden der String-Klasse?

static String join(String glue, String[] array) {
    String line = "";
    for (String s : array) line += s + glue;
    return (array.length == 0) ? line : line.substring(0, line.length() - glue.length());
}

Um "str1, str2" von "str1", "str2", "" zu erhalten:

Stream.of("str1", "str2", "").filter(str -> !str.isEmpty()).collect(Collectors.joining(", ")); 

Sie können auch eine zusätzliche Nullprüfung hinzufügen

Falls Sie eine funktionale Java-Bibliothek verwenden und aus irgendeinem Grund keine Streams aus Java 8 verwenden können (was bei Verwendung des Android + Retrolambda-Plugins der Fall sein kann), finden Sie hier eine funktionale Lösung für Sie:

String joinWithSeparator(List<String> items, String separator) {
    return items
            .bind(id -> list(separator, id))
            .drop(1)
            .foldLeft(
                    (result, item) -> result + item,
                    ""
            );
}

Beachten Sie, dass dies nicht der effizienteste Ansatz ist, aber für kleine Listen gut funktioniert.

Ich mache es so mit einem StringBuilder:

public static String join(String[] source, String delimiter) {
    if ((null == source) || (source.length < 1)) {
        return "";
    }

    StringBuilder stringbuilder = new StringBuilder();
    for (String s : source) {
        stringbuilder.append(s + delimiter);
    }
    return stringbuilder.toString();
} // join((String[], String)

Es gibt eine einfache Kurzschrifttechnik, die ich meistens benutze.

String op = new String;
for (int i : is) 
{
    op += candidatesArr[i-1]+",";
}
op = op.substring(0, op.length()-1);

java.util.Arrays hat eine 'asList'-Methode. Zusammen mit der API java.util.List / ArrayList erhalten Sie alles, was Sie brauchen:;

private static String[] join(String[] array1, String[] array2) {

    List<String> list = new ArrayList<String>(Arrays.asList(array1));
    list.addAll(Arrays.asList(array2));
    return list.toArray(new String[0]);
}