Supprimer le dernier caractère d'un StringBuilder?

Lorsque vous devez parcourir une collection et créer une chaîne de chaque donnée séparée par un délimiteur, vous vous retrouvez toujours avec un délimiteur supplémentaire à la fin, par exemple

for (String serverId : serverIds) {
  sb.append(serverId);
   sb.append(",");
}

Donne quelque chose comme: serverId_1, serverId_2, serverId_3,

Je voudrais supprimer le dernier caractère du StringBuilder (sans le convertir car j'en ai toujours besoin après cette boucle).

D'autres ont souligné la deleteCharAtméthode, mais voici une autre approche alternative:

String prefix = "";
for (String serverId : serverIds) {
  sb.append(prefix);
  prefix = ",";
  sb.append(serverId);
}

Sinon, utilisez la Joinerclasse de Guava :)

Depuis Java 8, StringJoinerfait partie du JRE standard.

Une autre solution simple est:

sb.setLength(sb.length() - 1);

Une solution plus compliquée:

La solution ci-dessus suppose que sb.length() > 0... c'est-à-dire qu'il y a un "dernier caractère" à supprimer. Si vous ne pouvez pas faire cette hypothèse, et / ou vous ne pouvez pas traiter l'exception qui se produirait si l'hypothèse est incorrecte, vérifiez d'abord la longueur du StringBuilder; par exemple

// Readable version
if (sb.length() > 0) {
   sb.setLength(sb.length() - 1);
}

ou

// Concise but harder-to-read version of the above.
sb.setLength(Math.max(sb.length() - 1, 0));

if(sb.length() > 0){
    sb.deleteCharAt(sb.length() - 1);
}

Depuis Java 8, la classe String possède une méthode statique join. Le premier argument est une chaîne que vous voulez entre chaque paire de chaînes, et le second est un Iterable<CharSequence>(qui sont les deux interfaces, donc quelque chose comme ça List<String>fonctionne. Donc vous pouvez simplement faire ceci:

String.join(",", serverIds);

Toujours en Java 8, vous pouvez utiliser la nouvelle StringJoinerclasse, pour les scénarios où vous souhaitez commencer à construire la chaîne avant d'avoir la liste complète des éléments à y mettre.

Obtenez simplement la position de la dernière occurrence de caractère.

for(String serverId : serverIds) {
 sb.append(serverId);
 sb.append(",");
}
sb.deleteCharAt(sb.lastIndexOf(","));

Depuis lastIndexOfeffectuera une recherche inversée, et vous savez qu'il trouvera au premier essai, les performances ne seront pas un problème ici.

ÉDITER

Puisque je continue de me lever sur ma réponse (merci les gens 😊), cela vaut la peine de le noter:

Sur Java 8 , il serait juste plus lisible et explicite d'utiliser StringJoiner . Il a une méthode pour un simple séparateur et une surcharge pour le préfixe et le suffixe.

Exemples tirés d'ici: exemple

Exemple utilisant un simple séparateur:

    StringJoiner mystring = new StringJoiner("-");    

    // Joining multiple strings by using add() method  
    mystring.add("Logan");  
    mystring.add("Magneto");  
    mystring.add("Rogue");  
    mystring.add("Storm");  

    System.out.println(mystring);

Production:

Logan-Magneto-Rogue-Storm

Exemple avec suffixe et préfixe:

    StringJoiner mystring = new StringJoiner(",", "(", ")");    

    // Joining multiple strings by using add() method  
    mystring.add("Negan");  
    mystring.add("Rick");  
    mystring.add("Maggie");  
    mystring.add("Daryl");  

    System.out.println(mystring);

Production

(Negan, Rick, Maggie, Daryl)

Dans ce cas,

sb.setLength(sb.length() - 1);

est préférable car il attribue simplement la dernière valeur à '\0'tandis que la suppression du dernier caractère neSystem.arraycopy

Avec Java-8vous pouvez utiliser une méthode statique de Stringclasse,

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

public class Test {

    public static void main(String[] args) {

        List<String> names = new ArrayList<>();
        names.add("James");
        names.add("Harry");
        names.add("Roy");
        System.out.println(String.join(",", names));
    }
}

PRODUCTION

James,Harry,Roy

Une autre alternative

for(String serverId : serverIds) {
   sb.append(",");
   sb.append(serverId); 
}
sb.deleteCharAt(0);

Alternativement,

StringBuilder result = new StringBuilder();
for(String string : collection) {
    result.append(string);
    result.append(',');
}
return result.substring(0, result.length() - 1) ;

StringBuilder sb = new StringBuilder();
sb.append("abcdef");
sb.deleteCharAt(sb.length() - 1);
assertEquals("abcde",sb.toString());
// true

Encore une autre alternative:

public String join(Collection<String> collection, String seperator) {
    if (collection.isEmpty()) return "";

    Iterator<String> iter = collection.iterator();
    StringBuilder sb = new StringBuilder(iter.next());
    while (iter.hasNext()) {
        sb.append(seperator);
        sb.append(iter.next());
    }

    return sb.toString();
}

Pour éviter de réinitier (affecter les performances) d' prefixutilisation TextUtils.isEmpty:

            String prefix = "";
            for (String item : list) {
                sb.append(prefix);
                if (TextUtils.isEmpty(prefix))
                    prefix = ",";
                sb.append(item);
            }

Vous pouvez essayer d'utiliser la classe «Joiner» au lieu de supprimer le dernier caractère de votre texte généré;

                List<String> textList = new ArrayList<>();
                textList.add("text1");
                textList.add("text2");
                textList.add("text3");

                Joiner joiner = Joiner.on(",").useForNull("null");
                String output = joiner.join(textList);

               //output : "text1,text2,text3"

Je fais quelque chose comme ci-dessous:

    StringBuilder stringBuilder = new StringBuilder();
    for (int i = 0; i < value.length; i++) {
        stringBuilder.append(values[i]);
        if (value.length-1) {
            stringBuilder.append(", ");
        }
    }

Voici une autre solution:

for(String serverId : serverIds) {
   sb.append(",");
   sb.append(serverId); 
}

String resultingString = "";
if ( sb.length() > 1 ) {
    resultingString = sb.substring(1);
}

Personnellement, j'aime ajouter un caractère de retour arrière (ou plus pour un "délimiteur" plus long) à la fin:

for(String serverId : serverIds) {
    sb.append(serverId);
    sb.append(",");
}

sb.append('\b');

Notez qu'il a des problèmes:

• comment \best affiché dépend de l'environnement,
• le length()du Stringcontenu peut être différent de la longueur des caractères « Visibile »

Lorsque cela \bsemble OK et que la longueur n'a pas d'importance, comme la connexion à une console, cela me semble assez bon.

stringBuilder.Remove (stringBuilder.Length - 1, 1);