Meilleur boucle Idiom pour cas spécial le dernier élément

Question

J'ai couru dans ce cas, beaucoup de temps quand on fait simple traitement de texte et d'imprimer des états où je suis en boucle sur une collection et je veux le cas particulier du dernier élément (par exemple, tous les éléments seront séparés par une virgule, sauf pour le dernier cas).

Est-il une meilleure pratique de l'idiome ou de forme élégante qui ne nécessite pas de duplication de code ou de se l'enfiler dans un si, d'autre dans la boucle.

Par exemple j'ai une liste de chaînes de caractères que je veux imprimer une liste séparée par des virgules. (le faire alors que la solution déjà suppose la liste a 2 ou plusieurs éléments sinon, il serait tout aussi mauvais que le plus correct pour la boucle conditionnelle).

par exemple, la Liste = ("chien", "chat", "chauve-souris")

Je veux imprimer "[chien, chat, chauve-souris]"

Je vous présente 2 méthodes de la

1. Pour la boucle conditionnelle

   public static String forLoopConditional(String[] items) {
   
   
   String itemOutput = "[";
   
   
   for (int i = 0; i < items.length; i++) {
       // Check if we're not at the last element
       if (i < (items.length - 1)) {
           itemOutput += items[i] + ", ";
       } else {
           // last element
           itemOutput += items[i];
       }
   }
   itemOutput += "]";
   
   
   return itemOutput;
    }
   

2. boucle do while amorçage de la boucle

   public static String doWhileLoopPrime(String[] items) {
   String itemOutput = "[";
   int i = 0;
   
   
   itemOutput += items[i++];
   if (i < (items.length)) {
       do {
           itemOutput += ", " + items[i++];
       } while (i < items.length);
   }
   itemOutput += "]";
   
   
   return itemOutput;
   }
   

   Testeur de classe:

   public static void main(String[] args) {
       String[] items = { "dog", "cat", "bat" };
   
   
   

Dans le Java AbstractCollection classe a la suite de la mise en œuvre (un peu verbeux, car il contient tous les bords cas de vérification d'erreur, mais pas mauvais).

}

Answer 1

Je l'écris habituellement comme ceci:

 static String commaSeparated(String[] items) {
    StringBuilder sb = new StringBuilder();
    String sep = "";
    for (String item: items) {
        sb.append(sep);
        sb.append(item);
        sep = ",";
    }
    return sb.toString();
}
 

Answer 2

Il y a beaucoup de boucles for dans ces réponses, mais je trouve qu'un Iterator et une boucle while sont beaucoup plus faciles à lire. Par exemple:

 Iterator<String> itemIterator = Arrays.asList(items).iterator();
if (itemIterator.hasNext()) {
  // special-case first item.  in this case, no comma
  while (itemIterator.hasNext()) {
    // process the rest
  }
}
 

C'est l'approche adoptée par Joiner dans les collections de Google et je la trouve très lisible.

Answer 3

string value = "[" + StringUtils.join( items, ',' ) + "]";

Answer 4

Ma prise habituelle est de tester si la variable d’index est zéro, par exemple:

 var result = "[ ";
for (var i = 0; i < list.length; ++i) {
    if (i != 0) result += ", ";
    result += list[i];
}
result += " ]";
 

Mais bien sûr, ce n’est que si nous parlons de langues qui n’ont pas de méthode Array.join (","). ;-)

Answer 5

Je pense qu'il est plus facile de considérer le premier élément comme un cas spécial car il est beaucoup plus facile de savoir si une itération est le premier plutôt que le dernier. Aucune logique complexe ou coûteuse n'est nécessaire pour savoir si quelque chose est fait pour la première fois.

 public static String prettyPrint(String[] items) {
    String itemOutput = "[";
    boolean first = true;

    for (int i = 0; i < items.length; i++) {
        if (!first) {
            itemOutput += ", ";
        }

        itemOutput += items[i];
        first = false;
    }

    itemOutput += "]";
    return itemOutput;
}