La dernière itération de renforcement de la boucle for en java

Une autre alternative est d'ajouter la virgule avant d'ajouter que j', tout simplement pas sur le première itération. (Merci de ne pas utiliser "" + i, en passant, vous n'avez pas vraiment envie de concaténation ici, et StringBuilder a un parfaitement bon append(int) surcharge.)

int[] array = {1, 2, 3...};
StringBuilder builder = new StringBuilder();

for (int i : array) {
    if (builder.length() != 0) {
        builder.append(",");
    }
    builder.append(i);
}

La bonne chose à ce sujet est qu'il fonctionne avec n'importe quel Iterable - vous ne pouvez pas toujours l'indice de choses. ("Ajouter la virgule, puis l'enlever à la fin" est une suggestion intéressante lorsque vous êtes vraiment en utilisant StringBuilder - mais il ne fonctionne pas pour des choses comme l'écriture des ruisseaux. C'est peut-être la meilleure approche à ce problème exact, cependant).

Il pourrait être plus facile de toujours ajouter. Et puis, quand vous en avez terminé avec votre boucle, il suffit de retirer le caractère final. Des tonnes de moins en moins les conditions de cette façon aussi.

Vous pouvez utiliser StringBuilder's deleteCharAt(int index) avec indice de length() - 1

C'est presque une répétition de cette question StackOverflow. Ce que vous voulez est StringUtils, et d'appeler le rejoindre méthode.

StringUtils.join(strArr, ',');

Explicite boucles fonctionnent toujours mieux qu'implicitement.

builder.append( "" + array[0] );
for( int i = 1; i != array.length; i += 1 ) {
   builder.append( ", " + array[i] );
}

Vous devez envelopper le tout dans un if seulement dans le cas où vous faites affaire avec un zéro-longueur du tableau.

Si vous le convertissez en un classique de l'indice de boucle, oui.

Ou vous pouvez simplement supprimer la dernière virgule après c'est fait. Comme:

int[] array = {1, 2, 3...};
StringBuilder

builder = new StringBuilder();

for(int i : array)
{
    builder.append(i + ",");
}

if(builder.charAt((builder.length() - 1) == ','))
    builder.deleteCharAt(builder.length() - 1);

Moi, je viens d'utiliser StringUtils.join() de commons-lang.

Basé sur java.util.AbstractCollection.toString(), il quitte tôt pour éviter le délimiteur.

StringBuffer buffer = new StringBuffer();
Iterator iter = s.iterator();
for (;;) {
  buffer.append(iter.next());
  if (! iter.hasNext())
    break;
  buffer.append(delimiter);
}

C'est efficace et élégant, mais pas aussi évident que certains des autres réponses.

Encore une autre option.

StringBuilder builder = new StringBuilder();
for(int i : array)
    builder.append(',').append(i);
String text = builder.toString();
if (text.startsWith(",")) text=text.substring(1);

Voici un SSCCE de référence, j'ai couru (liées à ce que j'avais à mettre en œuvre) avec ces résultats:

elapsed time with checks at every iteration: 12055(ms)
elapsed time with deletion at the end: 11977(ms)

Sur mon exemple au moins, en sautant la case à chaque itération n'est pas sensiblement plus rapide, surtout pour sane volumes de données, mais il est plus rapide.

import java.util.ArrayList;
import java.util.List;
public class TestCommas {
public static String GetUrlsIn(int aProjectID, List<String> aUrls, boolean aPreferChecks)
{
if (aPreferChecks) {
StringBuffer sql = new StringBuffer("select * from mytable_" + aProjectID + " WHERE hash IN ");
StringBuffer inHashes = new StringBuffer("(");
StringBuffer inURLs = new StringBuffer("(");
if (aUrls.size() > 0)
{
for (String url : aUrls)
{
if (inHashes.length() > 0) {
inHashes.append(",");
inURLs.append(",");
}
inHashes.append(url.hashCode());
inURLs.append("\"").append(url.replace("\"", "\\\"")).append("\"");//.append(",");
}
}
inHashes.append(")");
inURLs.append(")");
return sql.append(inHashes).append(" AND url IN ").append(inURLs).toString();
}
else {
StringBuffer sql = new StringBuffer("select * from mytable" + aProjectID + " WHERE hash IN ");
StringBuffer inHashes = new StringBuffer("(");
StringBuffer inURLs = new StringBuffer("(");
if (aUrls.size() > 0)
{
for (String url : aUrls)
{
inHashes.append(url.hashCode()).append(","); 
inURLs.append("\"").append(url.replace("\"", "\\\"")).append("\"").append(",");
}
}
inHashes.deleteCharAt(inHashes.length()-1);
inURLs.deleteCharAt(inURLs.length()-1);
inHashes.append(")");
inURLs.append(")");
return sql.append(inHashes).append(" AND url IN ").append(inURLs).toString();
}
}
public static void main(String[] args) { 
List<String> urls = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
urls.add("http://www.google.com/" + System.currentTimeMillis());
urls.add("http://www.yahoo.com/" + System.currentTimeMillis());
urls.add("http://www.bing.com/" + System.currentTimeMillis());
}
long startTime = System.currentTimeMillis();
for (int i = 0; i < 300; i++) {
GetUrlsIn(5, urls, true);
}
long endTime = System.currentTimeMillis();
System.out.println("elapsed time with checks at every iteration: " + (endTime-startTime) + "(ms)");
startTime = System.currentTimeMillis();
for (int i = 0; i < 300; i++) {
GetUrlsIn(5, urls, false);
}
endTime = System.currentTimeMillis();
System.out.println("elapsed time with deletion at the end: " + (endTime-startTime) + "(ms)");
}
}

Une autre approche est d'avoir la longueur du tableau (si disponible) stockée dans une variable distincte (plus efficace que de la re-vérification de la longueur à chaque fois). Vous pouvez ensuite comparer votre indice de cette longueur pour déterminer si ou de ne pas ajouter la virgule finale.

EDIT: une Autre considération est de pesage de la performance coût de la suppression d'un caractère final (ce qui peut causer une copie de chaîne) contre d'avoir un conditionnel être vérifié à chaque itération.

Dans ce cas, il n'y a vraiment pas besoin de savoir si c'est la dernière répétition.
Il existe de nombreuses façons que nous pouvons résoudre ce problème. Un autre moyen serait:

String del = null;
for(int i : array)
{
if (del != null)
builder.append(del);
else
del = ",";
builder.append(i);
}

Depuis son un tableau fixe, il serait plus facile d'éviter ces renforcée pour... Si l'Objet est une collection d'un itérateur serait plus facile.

int nums[] = getNumbersArray();
StringBuilder builder = new StringBuilder();
//non enhanced version
for(int i = 0; i < nums.length; i++){
builder.append(nums[i]);
if(i < nums.length - 1){
builder.append(",");
}   
}
//using iterator
Iterator<int> numIter = Arrays.asList(nums).iterator();
while(numIter.hasNext()){
int num = numIter.next();
builder.append(num);
if(numIter.hasNext()){
builder.append(",");
}
}