Java: fonction pour les tableaux comme join () de PHP?

Je veux rejoindre un String[]avec une chaîne de colle. Y a-t-il une fonction pour cela?

À partir de Java8, il est possible d'utiliser String.join().

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

Génère:

Hello, World, !

Sinon, Apache Commons Lang a une StringUtilsclasse qui a une joinfonction qui réunira les tableaux pour faire un String.

Par exemple:

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

Génère les éléments suivants String:

Hello, World, !

Si vous cherchiez quoi utiliser dans Android, c'est:

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

par exemple:

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

Dans Java 8, vous pouvez utiliser

1) API de diffusion:

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

2) nouvelle méthode 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

Vous pouvez facilement écrire une telle fonction dans une dizaine de lignes de code:

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

Un petit mod au lieu d'utiliser 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();
}

Comme pour de nombreuses questions ces derniers temps, Java 8 à la rescousse:

Java 8 a ajouté une nouvelle méthode statique java.lang.Stringqui fait exactement ce que vous voulez:

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

En l'utilisant:

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

Résulte en:

"Hello, World, !"

La bibliothèque de Google goyave a également ce genre de capacité . Vous pouvez également voir l'exemple String [] dans l'API.

Comme déjà décrit dans l'API, méfiez-vous de l'immuabilité des méthodes de construction.

Il peut accepter un tableau d'objets afin que cela fonctionne dans votre cas. Dans mon expérience précédente, j'ai essayé de rejoindre une pile qui est un itérable et cela fonctionne très bien.

Échantillon de moi:

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

imprime: |i am a coder|

Donné:

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

Ensuite, comme alternative à la réponse de coobird, où la colle est ",":

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

Ou pour concaténer avec une chaîne différente, telle que "& amp;".

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

Cependant ... celui-ci fonctionne UNIQUEMENT si vous savez que les valeurs du tableau ou de la liste NE contiennent PAS la chaîne de caractères ",".

Si vous utilisez Spring Framework, vous disposez de la classe StringUtils :

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

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

Pas dans le noyau, non. Une recherche de "colle de chaîne de jonction de tableau java" vous donnera quelques extraits de code sur la façon d'y parvenir.

par exemple

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

Si vous avez atterri ici à la recherche d'une conversion rapide de tableau en chaîne, essayez Arrays.toString () .

Crée une représentation String du Object[]passé. Le résultat est entouré de crochets ( "[]"), chaque élément est converti en une chaîne via le String.valueOf(Object)et séparé par ", ". Si le tableau l'est null, alors "null"est retourné.

Juste pour le défi "J'ai le plus court" , voici les mines;)

Itératif:

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

Récursif:

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

Rien de intégré que je sache.

Apache Commons Lang a une classe appelée StringUtilsqui contient de nombreuses fonctions de jointure.

Voilà comment je le fais.

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

Une alternative similaire

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

Mon tour.

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

Aimez-vous ma façon de 3 lignes en utilisant uniquement les méthodes de la 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());
}

Pour obtenir "str1, str2" à partir de "str1", "str2", "":

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

Vous pouvez également ajouter un contrôle nul supplémentaire

Dans le cas où vous utilisez la bibliothèque Java fonctionnelle et pour une raison quelconque, vous ne pouvez pas utiliser les flux de Java 8 (ce qui pourrait être le cas lorsque vous utilisez le plug-in Android + Retrolambda), voici une solution fonctionnelle pour vous:

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

Notez que ce n'est pas l'approche la plus efficace, mais cela fonctionne bien pour les petites listes.

Je le fais de cette façon en utilisant 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)

Il existe une technique de raccourci simple que j'utilise la plupart du temps.

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

java.util.Arrays a une méthode 'asList'. Avec l'API java.util.List / ArrayList, cela vous donne tout ce dont vous avez besoin :;

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