Une façon rapide et facile de joindre des éléments de tableau avec un séparateur (le contraire de split) En Java [dupliquer]

si vous êtes sur Android vous pouvez TextUtils.join(delimiter, tokens)

je préfère Google Collections plutôt que Apache StringUtils pour ce problème particulier:

Joiner.on(separator).join(array)

par rapport à StringUtils, L'API de menuisier a un design fluent et est un peu plus flexible, par exemple null éléments peuvent être sautés ou remplacés par un placeholder. En outre, Joiner a une caractéristique pour joindre des cartes avec un séparateur entre la clé et la valeur.

Apache Commons Lang a en effet un StringUtils.join la méthode qui permettra de relier les String des tableaux avec un séparateur spécifié.

par exemple:

String[] s = new String[] {"a", "b", "c"};
String joined = StringUtils.join(s, ",");  // "a,b,c"

cependant, je soupçonne que, comme vous le mentionnez, il doit y avoir une sorte de traitement conditionnel ou de substrat dans la mise en œuvre effective de la méthode mentionnée ci-dessus.

si je devais effectuer le String rejoignant et n'ayant pas d'autres raisons D'utiliser Commons Lang, Je roulerais probablement mon propre pour réduire le nombre de dépendances aux bibliothèques externes.

une solution simple et rapide sans aucun tiers comprend.

public static String strJoin(String[] aArr, String sSep) {
    StringBuilder sbStr = new StringBuilder();
    for (int i = 0, il = aArr.length; i < il; i++) {
        if (i > 0)
            sbStr.append(sSep);
        sbStr.append(aArr[i]);
    }
    return sbStr.toString();
}

" je suis sûr qu'il existe un moyen certifié et efficace de le faire (Apache Commons?) "

Oui, apparemment c'est

StringUtils.join(array, separator)

http://www.java2s.com/Code/JavaAPI/org.apache.commons.lang/StringUtilsjoinObjectarrayStringseparator.htm

vous pouvez utiliser remplacer et remplacer tout avec des expressions régulières.

String[] strings = {"a", "b", "c"};

String result = Arrays.asList(strings).toString().replaceAll("(^\[|\]$)", "").replace(", ", ",");

parce que Arrays.asList().toString() produit:" [a, b, c]", nous faisons un replaceAll pour supprimer les premier et dernier crochets et puis (optionnellement) vous pouvez changer le", "séquence pour", " (votre nouveau séparateur).

Une dépouillé version (moins de caractères):

String[] strings = {"a", "b", "c"};

String result = ("" + Arrays.asList(strings)).replaceAll("(^.|.$)", "").replace(", ", "," );

les expressions régulières sont très puissantes, spécialement les méthodes de chaîne de caractères "replaceFirst" et "replaceAll". De leur donner un essai.

encore plus facile vous pouvez juste utiliser des tableaux, de sorte que vous obtiendrez une chaîne avec les valeurs du tableau séparées par un ","

String concat = Arrays.toString(myArray);

donc vous finirez avec ceci: concat = "[a,b,c] "

mise à Jour

vous pouvez alors vous débarrasser des crochets en utilisant une sous-chaîne comme suggéré par Jeff

concat = concat.substring(1, concat.length() -1);

donc vous finissez avec concat = "a, b, c"

avec Java 1.8 il y a une nouvelle Classe StringJoiner - donc pas besoin de Guava ou Apache communes:

String str = new StringJoiner(",").add("a").add("b").add("c").toString();

ou en utilisant une collection directement avec la nouvelle api stream:

String str = Arrays.asList("a", "b", "c").stream().collect(Collectors.joining(","));

toutes ces autres réponses incluent runtime overhead... comme utiliser ArrayList.toString ().replaceAll (...) qui sont très inutile.

je vais vous donner l'algorithme optimal avec zéro overhead; il ne semble pas aussi joli que les autres options, mais à l'intérieur, c'est ce qu'ils font tous (après des piles d'autres vérifications cachées, l'allocation de tableaux multiples et d'autres crud).

comme vous savez déjà que vous avez affaire à des cordes, vous pouvez enregistrer un tas d'attributions de tableaux en exécutant tout manuellement. Ce n'est pas joli, mais si vous retracez les appels de méthode réels faits par les autres implémentations, vous verrez qu'il y a le moins de dépassement d'exécution possible.

public static String join(String separator, String ... values) {
  if (values.length==0)return "";//need at least one element
  //all string operations use a new array, so minimize all calls possible
  char[] sep = separator.toCharArray();

  // determine final size and normalize nulls
  int totalSize = (values.length - 1) * sep.length;// separator size
  for (int i = 0; i < values.length; i++) {
    if (values[i] == null)
      values[i] = "";
    else
      totalSize += values[i].length();
  }

  //exact size; no bounds checks or resizes
  char[] joined = new char[totalSize];
  int pos = 0;
  //note, we are iterating all the elements except the last one
  for (int i = 0, end = values.length-1; i < end; i++) {
    System.arraycopy(values[i].toCharArray(), 0, 
      joined, pos, values[i].length());
    pos += values[i].length();
    System.arraycopy(sep, 0, joined, pos, sep.length);
    pos += sep.length;
  }
  //now, add the last element; 
  //this is why we checked values.length == 0 off the hop
  System.arraycopy(values[values.length-1].toCharArray(), 0,
    joined, pos, values[values.length-1].length());

  return new String(joined);
}

cette option est rapide et claire:

  public static String join(String separator, String... values) {
    StringBuilder sb = new StringBuilder(128);
    int end = 0;
    for (String s : values) {
      if (s != null) {
        sb.append(s);
        end = sb.length();
        sb.append(separator);
      }
    }
    return sb.substring(0, end);
  }

c'est dans StringUtils:

http://www.java2s.com/Code/JavaAPI/org.apache.commons.lang/StringUtilsjoinObjectarrayStringseparator.htm

cette petite fonction est toujours pratique.

public static String join(String[] strings, int startIndex, String separator) {
    StringBuffer sb = new StringBuffer();
    for (int i=startIndex; i < strings.length; i++) {
        if (i != startIndex) sb.append(separator);
        sb.append(strings[i]);
    }
    return sb.toString();
}

l'approche que j'ai adoptée a évolué depuis Java 1.0 Pour fournir la lisibilité et maintenir des options raisonnables pour rétrocompatibilité avec les versions Java plus anciennes, tout en fournissant également des signatures de méthode qui sont des remplacements pour ceux de apache commons-lang. Pour des raisons de performance, je peux voir quelques objections possibles à l'utilisation de tableaux.asList mais je préfère les méthodes d'aide qui ont des valeurs par défaut sensées sans dupliquer la méthode qui exécute le travail réel. Ce l'approche fournit des points d'entrée appropriés à une méthode fiable qui ne nécessite pas de conversions tableau/liste avant l'appel.

les variations possibles pour la compatibilité de version Java incluent le remplacement de StringBuffer (Java 1.0) par StringBuilder (Java 1.5), le remplacement de L'itérateur Java 1.5 et la suppression du caractère générique (Java 1.5) de la Collection (Java 1.2). Si vous voulez prendre rétrocompatibilité un peu plus loin, supprimer les méthodes qui utilisent Collection et déplacez la logique dans la méthode basée sur les tableaux.

public static String join(String[] values)
{
    return join(values, ',');
}

public static String join(String[] values, char delimiter)
{
    return join(Arrays.asList(values), String.valueOf(delimiter));
}

// To match Apache commons-lang: StringUtils.join(values, delimiter)
public static String join(String[] values, String delimiter)
{
    return join(Arrays.asList(values), delimiter);
}

public static String join(Collection<?> values)
{
    return join(values, ',');
}

public static String join(Collection<?> values, char delimiter)
{
    return join(values, String.valueOf(delimiter));
}

public static String join(Collection<?> values, String delimiter)
{
    if (values == null)
    {
        return new String();
    }

    StringBuffer strbuf = new StringBuffer();

    boolean first = true;

    for (Object value : values)
    {
        if (!first) { strbuf.append(delimiter); } else { first = false; }
        strbuf.append(value.toString());
    }

    return strbuf.toString();
}

public String join(String[] str, String separator){
    String retval = "";
    for (String s: str){ retval+= separator + s;}
    return retval.replaceFirst(separator, "");
}