Dernière itération de la boucle for améliorée en java

Existe-t-il un moyen de déterminer si la boucle est itérée pour la dernière fois? Mon code ressemble à ceci:

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

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

Maintenant, le problème est que je ne veux pas ajouter de virgule dans la dernière itération. Existe-t-il maintenant un moyen de déterminer si c'est la dernière itération ou si je suis coincé avec la boucle for ou si j'utilise un compteur externe pour garder une trace.

Une autre alternative consiste à ajouter la virgule avant d'ajouter i, mais pas lors de la première itération. (Veuillez ne pas utiliser "" + i, au fait - vous ne voulez pas vraiment de concaténation ici, et StringBuilder a une surcharge d'ajout (int) parfaitement bonne.)

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 que cela fonctionnera avec n'importe lequel Iterable- vous ne pouvez pas toujours indexer les choses. (Le "ajouter la virgule puis la supprimer à la fin" est une bonne suggestion lorsque vous utilisez vraiment StringBuilder - mais cela ne fonctionne pas pour des choses comme l'écriture dans des flux. C'est probablement la meilleure approche pour ce problème précis. )

Une autre façon de procéder:

String delim = "";
for (int i : ints) {
    sb.append(delim).append(i);
    delim = ",";
}

Mise à jour: pour Java 8, vous disposez désormais de collecteurs

Il peut être plus facile de toujours ajouter. Et puis, lorsque vous avez terminé votre boucle, supprimez simplement le caractère final. Des tonnes moins conditionnelles de cette façon aussi.

Vous pouvez utiliser StringBuilderdes deleteCharAt(int index)avec l'index étantlength() - 1

Peut-être que vous utilisez le mauvais outil pour le travail.

C'est plus manuel que ce que vous faites mais c'est en quelque sorte plus élégant sinon un peu "old school"

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

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

StringUtils.join(strArr, ',');

Une autre solution (peut-être la plus efficace)

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

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

restez simple et utilisez une boucle for standard:

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

ou utilisez simplement apache commons-lang StringUtils.join ()

Les boucles explicites fonctionnent toujours mieux que les boucles implicites.

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

Vous devriez envelopper le tout dans une instruction if juste au cas où vous auriez affaire à un tableau de longueur nulle.

Si vous le convertissez en une boucle d'index classique, oui.

Ou vous pouvez simplement supprimer la dernière virgule après avoir terminé. Ainsi:

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, j'utilise juste StringUtils.join()de commons-lang .

Vous avez besoin d'un séparateur de classe .

Separator s = new Separator(", ");
for(int i : array)
{
     builder.append(s).append(i);
}

La mise en œuvre de la classe Separatorest simple. Il encapsule une chaîne qui est retournée à chaque appel de, à l' toString()exception du premier appel, qui renvoie une chaîne vide.

Basé sur java.util.AbstractCollection.toString (), il se termine 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 certaines des autres réponses.

Voici une solution:

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

for(int i : array)
{
    if(!firstiteration)
        builder.append(",");

    builder.append("" + i);
    firstiteration=false;
}

Recherchez la première itération :)  

Comme la boîte à outils l'a mentionné, dans Java 8, nous avons maintenant des collecteurs . Voici à quoi ressemblerait le code:

String joined = array.stream().map(Object::toString).collect(Collectors.joining(", "));

Je pense que cela fait exactement ce que vous recherchez, et c'est un modèle que vous pourriez utiliser pour beaucoup d'autres choses.

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

Bon nombre des solutions décrites ici sont un peu exagérées, à mon humble avis, en particulier celles qui reposent sur des bibliothèques externes. Il existe une belle expression propre et claire pour créer une liste séparée par des virgules que j'ai toujours utilisée. Il repose sur l'opérateur conditionnel (?):

Edit : Solution d'origine correcte, mais non optimale selon les commentaires. Essayer une deuxième fois:

    int[] array = {1, 2, 3};
    StringBuilder builder = new StringBuilder();
    for (int i = 0 ;  i < array.length; i++)
           builder.append(i == 0 ? "" : ",").append(array[i]); 

Voilà, en 4 lignes de code comprenant la déclaration du tableau et le StringBuilder.

Voici un benchmark SSCCE que j'ai exécuté (lié à ce que je devais implémenter) 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, sauter le contrôle à chaque itération est pas sensiblement plus rapide en particulier pour les volumes sains 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 consiste à stocker la longueur du tableau (si disponible) dans une variable distincte (plus efficace que de revérifier la longueur à chaque fois). Vous pouvez ensuite comparer votre index à cette longueur pour déterminer s'il faut ou non ajouter la virgule finale.

EDIT: Une autre considération est de peser le coût de performance de la suppression d'un caractère final (qui peut provoquer une copie de chaîne) par rapport à la vérification d'un conditionnel à chaque itération.

Si vous ne transformez un tableau qu'en un tableau délimité par des virgules, de nombreux langages ont une fonction de jointure pour exactement cela. Il transforme un tableau en une chaîne avec un délimiteur entre chaque élément.

Dans ce cas, il n'est vraiment pas nécessaire de savoir s'il s'agit de la dernière répétition. Il existe de nombreuses façons de résoudre ce problème. Une solution serait:

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

Deux chemins alternatifs ici:

1: Utils de chaîne Apache Commons

2: Gardez un booléen appelé first, défini sur true. Dans chaque itération, si firstest faux, ajoutez votre virgule; après cela, définissez firstsur false.

Puisqu'il s'agit d'un tableau fixe, il serait plus facile d'éviter simplement le pour ... Si l'objet est une collection, 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(",");
   }
}