Java pour la boucle vs boucle while. Différence de Performance?

Assumer, j'ai le code suivant, il y a trois boucle for pour faire quelque chose. Serait-il courir vite si je change le plus extérieur de la boucle pour boucle while? merci~~ 

int length = 200;
int test = 0;
int[] input = new int[10];

for(int i = 1; i <= length; i++) {
    for (int j = 0; j <=length - i; j++) {
        for (int k = 0; k < length - 1; k++) {
            test = test + input[j + k];
        }
    }
}
Il va optimiser pour test = 0; car le tableau n'est pas renseigné si test = test + entrée[j + k]; sera toujours zéro.
Temps! aussi idk java, mais je sais en perl C style pour les boucles sont plus lents que les boucles while esp dans le cas de la lecture de fichiers.

OriginalL'auteur | 2009-07-22

  1. 54

    Pas, changer le type de la boucle ne serait pas question.

    La seule chose qui peut le rendre plus rapide serait d'avoir moins d'imbrication de boucle, et en boucle sur les valeurs.

    La seule différence entre un for boucle et un while boucle est la syntaxe pour la définition. Il n'y a pas de différence de performances à tous.

    int i = 0;
while (i < 20){
    //do stuff
    i++;
}

    Est la même chose que:

    for (int i = 0; i < 20; i++){
    //do Stuff
}

    (En fait, la boucle for est un peu mieux parce que la i sera hors de portée après la boucle tandis que la i coller autour de la while boucle cas.)

    D'une boucle for est juste un point de vue syntaxique plus jolie façon de bouclage.

    vous pouvez ajouter de la portée de la je de le frapper hors de la pile une fois que vous avez fini avec elle 😀
    Une boucle for et un peu de temps de la boucle est en fait légèrement différents, en raison de comment continuer à se comporte. L'incrémentation se produit toujours dans la boucle alors que de continuer dans la boucle serait ignorer, ce qui provoque la boucle pour aller à l'infini.
    Pourquoi n'est-ce pas la bonne réponse? À mon humble avis c'est ce qui explique exactement comment travailler avec ces boucles.

    OriginalL'auteur jjnguy

  2. 31

    Ce genre de micro-optimisation est inutile.

    • Un tout-boucle ne sera pas plus rapide.
    • La structure de boucle est pas votre goulot d'étranglement.
    • Optimiser votre premier algorithme.
    • Mieux encore, ne pas optimiser en premier. Optimiser fois que vous avez découvert que vous avez vraiment un goulot d'étranglement dans votre algorithme qui n'est pas I/O-dépendant.

    OriginalL'auteur Bombe

  3. 10

    vous ne pouvez pas l'optimiser en modifiant à tout.

    vous pouvez simplement incrément de vitesse très très très très peu en changeant la ligne

    for (int k = 0; k < length - 1; k++) {

    par

    for (int k = 0; k < lengthMinusOne; k++) {

    où lengthMinusOne est calculée avant

    cette soustraction est juste calcul de près (200x201/2) x (200-1) fois et il est très petit nombre pour ordinateur 🙂

    Le compilateur Java permettra d'optimiser qui appellent généralement ces jours-ci. Mais vous êtes techniquement correcte à ce sujet étant plus rapide.
    Heh, j'étais à moitié quelqu'un attend de suggérer de changer de k++ à ++k 😀
    vous permettra d'économiser de très très très très peu de temps de compilation. La plupart des compilateurs maintenant de soutenir de telles optimisations case stackoverflow.com/questions/5981460/...

    OriginalL'auteur ufukgun

  4. 7

    Quelqu'un a suggéré de tester while vs for boucles, j'ai donc créé un code pour tester si les boucles while ou pour les boucles ont été les plus rapides; en moyenne, plus de 100 000 tests, while boucle a été plus rapide ~95% du temps. J'ai peut-être codés de manière incorrecte, je suis assez nouveau dans le codage, d'autant plus si je ne courait de 10 000 boucles qu'il a fini par être tout à fait bien dans la course de durée.

    modifier je n'ai pas changer toutes les valeurs de tableau quand je suis allé tester pour plus d'essais. Il fixe, de sorte qu'il est plus facile de changer la façon dont de nombreuses épreuves vous exécutez.

    import java.util.Arrays;
class WhilevsForLoops {
public static void main(String[] args) {
final int trials = 100; //change number of trials
final int trialsrun = trials - 1;
boolean[] fscount = new boolean[trials]; //faster /slower boolean
int p = 0; //while counter variable for for/while timers
while (p <= trialsrun) {
long[] forloop = new long[trials];
long[] whileloop = new long[trials];
long systimeaverage; 
long systimenow = System.nanoTime();
long systimethen = System.nanoTime();
System.out.println("For loop time array : ");
for (int counter=0;counter <= trialsrun; counter++) {
systimenow = System.nanoTime();
System.out.print(" #" + counter + " @");
systimethen = System.nanoTime();
systimeaverage = (systimethen - systimenow);
System.out.print( systimeaverage + "ns |");
forloop[counter] = systimeaverage; 
}
int count = 0;
System.out.println(" ");
System.out.println("While loop time array: ");
while (count <= trialsrun) {
systimenow = System.nanoTime();
System.out.print(" #" + count + " @");
systimethen = System.nanoTime();
systimeaverage = (systimethen - systimenow);
System.out.print( systimeaverage + "ns |");
whileloop[count] = systimeaverage;
count++;
}
System.out.println("===============================================");
int sum = 0;
for (int i = 0; i <= trialsrun; i++) {
sum += forloop[i];
}
System.out.println("for loop time average: " + (sum / trials) + "ns");
int sum1 = 0;
for (int i = 0; i <= trialsrun; i++) {
sum1 += whileloop[i];
}
System.out.println("while loop time average: " + (sum1 / trials) + "ns");
int longer = 0;
int shorter = 0;
int gap = 0;
sum = sum / trials;
sum1 = sum1 / trials; 
if (sum1 > sum) {
longer = sum1;
shorter = sum;
}
else {
longer = sum;
shorter = sum1;
}
String longa;
if (sum1 > sum) {
longa = "~while loop~";
}
else {
longa = "~for loop~";
}
gap = longer - shorter; 
System.out.println("The " + longa + " is the slower loop by: " + gap + "ns");
if (sum1 > sum) {
fscount[p] = true; }
else {
fscount[p] = false;
}
p++;
}
int forloopfc=0;
int whileloopfc=0;
System.out.println(Arrays.toString(fscount));
for(int k=0; k <= trialsrun; k++) {
if (fscount[k] == true) {
forloopfc++; }
else {
whileloopfc++;}
}
System.out.println("--------------------------------------------------");
System.out.println("The FOR loop was faster: " + forloopfc + " times.");
System.out.println("The WHILE loop was faster: " + whileloopfc + " times.");
}
}

    OriginalL'auteur Sleepy

  5. 2

    Même si l'hypothèse de la boucle while étant plus rapide que la boucle était vrai (et il n'est pas), les boucles que vous auriez dû modifier/optimiser ne serait pas de l'extérieur mais de l'intérieur, car celles-ci sont exécutées plusieurs fois.

    OriginalL'auteur fortran

  6. 2

    La différence entre les pour et tout est sémantique :

    • Dans une boucle while, vous aurez la boucle tant que la condition est vrai, qui peut varier beaucoup, car vous risquez de vous, dans votre boucle, modifier les variables à l'aide de evluating la condition du while.
    • Généralement, dans une boucle for, vous N boucle du temps. Ce N peut être variable, mais ne bouge pas jusqu'à la fin de votre N de la boucle, comme d'habitude des développeurs de ne pas modifier les variables d'évaluation de la condition de la boucle.

    C'est un moyen d'aider les autres à comprendre votre code. Vous n'êtes pas obligé de ne pas modifier pour les variables de boucle, mais il est courant (et bonnes) pratiques.

    OriginalL'auteur Clement Herreman

  7. 2

    voici une lien à un article sur le sujet

    selon elle, le moment et Pour sont presque deux fois plus vite, mais les deux sont les mêmes.

    MAIS cet article a été écrit en 2009 et donc je l'ai essayé sur ma machine et voici les résultats:

    • à l'aide de java 1.7: l'Itérateur était d'environ 20% à 30% plus rapide que For et While (qui ont toujours le même)
    • à l'aide de la version 1.6 de java: l'Itérateur était d'environ 5% plus rapide que For et While (qui ont toujours le même)

    donc je suppose que la meilleure chose, c'est juste le temps sur votre propre version de la machine et de et de conclure que

    Dans toutes les mesures de sécurité de la langue, de l'utilisation d'un itérateur est généralement plus rapide, puisque l'interpréteur/compilateur peut omettre lié vérification.

    OriginalL'auteur levtatarov

  8. 1

    Non, vous êtes toujours en boucle le même nombre de fois. N'importe pas.

    OriginalL'auteur aquinas

  9. 1

    Regardez votre algorithme! Faites-vous connaître à l'avance les valeurs de votre tableau sont ajoutés plusieurs fois?

    Si vous savez que vous pourriez réduire le nombre de boucles et qui permettrait d'aboutir à de meilleures performances.

    OriginalL'auteur Roalt

  10. 0

    Il ne serait d'importance si vous utilisez le multi-thread ou plusieurs processeurs de programmation. Il serait dépend de la façon dont vous affectez les boucles pour les différents processeurs/threads.

    OriginalL'auteur Extrakun

  11. 0

    Il n'y aurait pas de différence de performances. L'essayer!

    La JVM et de plus, le compilateur, serait de faire deux boucles en quelque chose comme

        label:
;code inside your for loop.
LOOP label

    OriginalL'auteur Adrian

  12. 0

    Quelqu'un a essayé comme ça...

    int i = 20;
while (--i > -1){
//do stuff
}

    Par rapport à:

    for (int i = 0; i < 20; i++){
    //do Stuff
}

    OriginalL'auteur Danilo Castro

  13. 0

    En Boucle et en boucle sont même

    http://www.mkyong.com/java/while-loop-for-loop-and-iterator-performance-test-java/

    la conclusion de votre lien montre que l'Itérateur mécanisme est la méthode la plus lente pour faire une boucle dans une liste. Il n'y a pas beaucoup de spectacle, les différents entre les Pour et boucle While.
    L'article n'est même pas dire que la boucle While est plus rapide que la boucle For.

    OriginalL'auteur Abhishek Gaikwad

  14. -1

    Sur cette base: https://jsperf.com/loops-analyze (pas créé par moi) de la boucle while est de 22% plus lente qu'une boucle for en général. Au moins en Javascript, il est.

    OriginalL'auteur Arash R