Une boucle apparemment sans fin se termine, sauf si System.out.println est utilisé

Question

J'ai eu un peu simple de code qui était censé être une boucle sans fin depuis x sera toujours de plus en plus et de rester toujours plus grand que j.

int x = 5;
int y = 9;
for (int j = 0; j < x; j++) {
   x = x + y;
}
System.out.println(y);

mais comme c'est, il imprime y et ne tourne pas en boucle à l'infini. Je ne peux pas comprendre pourquoi. Cependant, quand j'ai régler le code de la manière suivante:

int x = 5;
int y = 9;
for (int j = 0; j < x; j++) {
    x = x + y;
    System.out.println(y);
}
System.out.println(y);

Il devient une boucle sans fin et je n'ai aucune idée pourquoi. Java reconnaître ses une boucle sans fin et de sauter dans la première situation, mais doit exécuter un appel de méthode dans la seconde, de sorte qu'il se comporte comme prévu? Confus :)

Answer 1

Les deux exemples ne sont pas infinies.

Le problème est la limitation de l' int type en Java (ou à peu près n'importe quel autre langage). Lorsque la valeur de x atteint 0x7fffffff, en ajoutant toute positive de la valeur de débordement et de l' x devient négatif, donc plus faible que j.

La différence entre la première et la deuxième boucle est à l'intérieur de code prend beaucoup plus de temps et il serait probablement prendre plusieurs minutes jusqu' x débordements. Pour le premier exemple, il peut prendre moins de seconde ou plus probablement le code sera supprimé par l'optimiseur comme il n'a aucun effet.

Comme mentionné dans la discussion, le temps dépendra fortement de la façon dont OS tampons de la sortie, si elle renvoie à l'émulateur de terminal etc., de sorte qu'il peut être beaucoup plus élevé que quelques minutes.

Answer 2

Comme ils sont déclarés en tant qu'int, une fois que la valeur maximale est atteinte, la boucle se rompt lorsque la valeur x devient négative.

Cependant, lorsque System.out.println est ajouté à la boucle, la vitesse d'exécution devient visible (la sortie sur la console ralentissant la vitesse d'exécution). Cependant, si vous laissez le second programme (celui avec syso dans la boucle) fonctionner assez longtemps, il devrait avoir le même comportement que le premier (celui sans syso dans la boucle).

Answer 3

Il peut y avoir deux raisons à cela:

1. Java optimise l' for boucle et depuis il n'y a pas d'utilisation d' x après la boucle, tout simplement supprime la boucle. Vous pouvez vérifier cela en mettant System.out.println(x); déclaration après la boucle.

2. Il peut être possible que Java n'est pas réellement l'optimisation de la boucle et il est d'exécuter correctement le programme et, éventuellement, x va devenir trop volumineux pour int de dépassement et de. Débordement d'entier sera très probablement prendre de l'entier x comme négatifs, qui sera plus petit que j et donc, il va sortir de la boucle et imprimer la valeur de y. Cela peut également être vérifiée par l'ajout d' System.out.println(x); après la boucle.

Aussi, même dans le premier cas par déborder va se passer rendant ainsi le second cas, il ne sera jamais un vrai boucle sans fin.

Answer 4

Ils sont à la fois pas les boucles sans fin, au départ j = 0 , tant que j < x, j augmente(j++), et j est un entier donc, la boucle est exécuté jusqu'à ce qu'il atteigne la valeur maximale, puis de dépassement(Un Dépassement d'Entier est la condition qui se produit lorsque le résultat d'une opération arithmétique, tels que la multiplication ou l'addition, dépasse la taille maximale d'un entier de type utilisé pour stocker.). pour le deuxième exemple, le système imprime la valeur de y jusqu'à ce que la boucle de pauses.

si vous êtes à la recherche pour un exemple d'une boucle sans fin, il devrait ressembler à ceci

int x = 6;

for (int i = 0; x < 10; i++) {
System.out.println("Still Looping");
}

parce que (x) ne serait jamais atteindre la valeur de 10;

vous pouvez également créer une boucle infinie avec une double boucle for:

int i ;

  for (i = 0; i <= 10; i++) {
      for (i = 0; i <= 5; i++){
         System.out.println("Repeat");   
      }
 }

cette boucle est infinie parce que la première boucle for, dit-i < 10, ce qui est vrai si elle va dans le deuxième boucle for et la deuxième boucle for augmente la valeur de (i) jusqu'à ce qu'il est == 5. Ensuite, il procède à la première pour boucle à nouveau parce que i < 10,le processus ne cesse de répéter à lui-même parce qu'il se réinitialise après la seconde boucle for

Answer 5

C'est une boucle finie, car une fois que la valeur de x dépasse 2,147,483,647 (qui est la valeur maximale de l' int), x devient négatif et pas plus grand que j plus, si vous imprimez y ou pas.

Il vous suffit de modifier la valeur de y de 100000 et imprimer y dans la boucle et la boucle break très bientôt.

La raison pour laquelle vous vous sentez qu'il est devenu infini, c'est que l' System.out.println(y); faites le code pour être exécutés de manière beaucoup plus lente que sans actions.