Des méthodes efficaces pour l'Incrémentation et la Décrémentation dans la même Boucle

Supposons qu'il existe certaines situations où vous voulez incrémenter et décrémenter les valeurs dans la même boucle. Dans cette série de situations, il y a certains cas où vous pouvez "tricher" en prenant avantage de la nature de la situation, par exemple, l'inversion d'une chaîne de caractères.

En raison de la nature de la construction de chaînes de caractères, nous n'avons pas vraiment de manipuler l'itération ou ajouter un compteur:

public static void stringReversal(){
    String str = "Banana";
    String forwardStr = new String();
    String backwardStr = new String();

    for(int i = str.length()-1; i >= 0; i--){
        forwardStr = str.charAt(i)+forwardStr;
        backwardStr = backwardStr+str.charAt(i);
    }

    System.out.println("Forward String:  "+forwardStr);
    System.out.println("Backward String: "+backwardStr);   
}

Cependant, supposons un cas différent est le cas lorsque nous voulons juste l'impression d'un décrémenté de la valeur, de la valeur initiale de 0 et une valeur incrémentée de 0 à la valeur initiale.

public static void incrementAndDecrement(){

   int counter = 0;

   for(int i = 10; i >= 0; i--){
       System.out.println(i);
       System.out.println(counter);
       counter++;
   } 
}

Cela fonctionne assez bien, mais avoir à créer un deuxième compteur à incrémentation semble désordonné. Existe-il des mathématiques trucs ou astuces impliquant la boucle for qui pourrait être utilisée pour faire counter redondant?

Quel est le problème avec un simple calcul arithmétique? 10 - i?
La privation de sommeil, je crois.
Il arrive aux meilleurs d'entre nous.

OriginalL'auteur Anthony Neace | 2012-10-17

  1. 8

    Eh bien, il semble comme vous voulez juste:

    for(int i = 10; i >= 0; i--){
    System.out.println(i);
    System.out.println(10 - i);
}

    Est-ce le cas? Personnellement, je serais normalement écrire cela comme une l'augmentation de boucle, que je trouve plus facile de penser que:

    for (int i = 0; i <= 10; i++) {
    System.out.println(10 - i);
    System.out.println(i);
}

    Noter que votre exemple de chaîne est vraiment inefficace, en passant, bien plus que l'introduction d'une variable supplémentaire. Étant donné que vous connaissez les longueurs impliqués pour commencer, vous pouvez juste commencer avec deux char[] de la bonne taille, et de remplir la droite de l'index à chaque fois. Puis de créer une chaîne de chacun par la suite. Encore une fois, je le ferais avec un l'augmentation de boucle:

    char[] forwardChars = new char[str.length()];
char[] reverseChars = new char[str.length()];
for (int i = 0; i < str.length(); i++) {
    forwardChars[i] = str.charAt(i);
    reverseChars[reverseChars.length - i - 1] = str.charAt(i);
}
String forwardString = new String(forwardChars);
String reverseString = new String(reverseChars);

    (Bien sûr forwardString va juste être égal à str dans ce cas, de toute façon...)

    Holy crap, Jon Skeet!
    et maintenant, le upvoting commence!! 😉
    En fait j'ai été en espérant que cela permettrait d'obtenir une discussion sur l'efficacité de ces sortes de problèmes, mais je n'étais pas sûr de la façon de travailler que sur la question. Merci de prendre la peine de donner des précisions sur les deux exemples!

    OriginalL'auteur Jon Skeet

  2. 5

    Vous pouvez avoir plusieurs variables et incrementers dans un for boucle.

    for(int i = 10, j = 0; i >= 0; i--, j++) {
    System.out.println(i);
    System.out.println(j);
}
    comment est-ce différent de l'ajout d'une variable de compteur?...la question est de réduire le nombre de variables.
    Il n'est pas. Il a juste demandé à être moins "bordélique" et l'implication de la boucle for, alors j'ai pensé que ce pourrait bien être ce qu'il cherche. 🙂
    +1 pour élargir mes connaissances sur le sujet. Il est en effet moins "bordélique" comme il conserve tout dans la boucle, et en tant que tel dans les limites de ma question.

    OriginalL'auteur gnunaes