Java: funzione per array come join () di PHP?

Voglio unire un String[]con una stringa di colla. C'è una funzione per questo?

A partire da Java8 è possibile utilizzare String.join().

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

genera:

Hello, World, !

Altrimenti, Apache Commons Lang ha una StringUtilsclasse che ha una joinfunzione che unirà le matrici per creare un String.

Per esempio:

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

Genera quanto segue String:

Hello, World, !

Se stavi cercando cosa usare in Android, è:

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

per esempio:

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

In Java 8 puoi usare

1) API Stream:

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

2) nuovo metodo String.join: https://stackoverflow.com/a/21756398/466677

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

Si potrebbe facilmente scrivere una tale funzione in circa dieci righe di codice:

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

Una piccola mod invece di usare la sottostringa ():

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

Come con molte domande di recente, Java 8 in soccorso:

Java 8 ha aggiunto un nuovo metodo statico al java.lang.Stringquale fa esattamente quello che vuoi:

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

Usandolo:

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

Risultati in:

"Hello, World, !"

Anche la libreria di Google guava ha questo tipo di funzionalità . Puoi vedere l'esempio String [] anche dall'API.

Come già descritto nell'API, fai attenzione all'immutabilità dei metodi di costruzione.

Può accettare una serie di oggetti, quindi funzionerà nel tuo caso. Nella mia precedente esperienza, ho provato a unirmi a uno Stack che è iterabile e funziona benissimo.

Campione da me:

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

stampa: |i am a coder|

Dato:

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

Quindi come alternativa alla risposta di coobird, dove la colla è ",":

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

O concatenare con una stringa diversa, come "& amp;".

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

Tuttavia ... questo funziona SOLO se sai che i valori nella matrice o nell'elenco NON contengono la stringa di caratteri ",".

Se stai usando Spring Framework allora hai la classe StringUtils :

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

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

Non nel nocciolo, no. Una ricerca di "colla per stringhe di join java array" ti fornirà alcuni frammenti di codice su come raggiungere questo obiettivo.

per esempio

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

Se sei arrivato qui alla ricerca di una rapida conversione da array a stringa, prova Arrays.toString () .

Crea una rappresentazione String del Object[]passato. Il risultato è racchiuso tra parentesi ( "[]"), ogni elemento viene convertito in una stringa tramite il String.valueOf(Object)e separato da ", ". Se l'array è null, "null"viene restituito.

Solo per la sfida "Ho la più breve" , ecco le mine;)

Iterativo:

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

Ricorsivo:

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

Niente di incorporato che io sappia.

Apache Commons Lang ha una classe chiamata StringUtilsche contiene molte funzioni di join.

Questo è come lo faccio.

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

Un'alternativa simile

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

Il mio giro.

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

Ti piace il mio modo a 3 righe usando solo i metodi della classe String?

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

Per ottenere "str1, str2" da "str1", "str2", "":

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

Inoltre è possibile aggiungere un ulteriore controllo null

Nel caso in cui tu stia utilizzando la libreria Java funzionale e per qualche motivo non riesci a utilizzare Streams da Java 8 (che potrebbe essere il caso quando si utilizza il plug-in Android + Retrolambda), ecco una soluzione funzionale per te:

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

Si noti che non è l'approccio più efficiente, ma funziona bene per piccoli elenchi.

Lo faccio in questo modo usando un 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)

Esiste una semplice tecnica abbreviata che uso la maggior parte delle volte.

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

java.util.Arrays ha un metodo 'asList'. Insieme all'API java.util.List / ArrayList ti offre tutto ciò di cui hai bisogno :;

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