Je veux comprendre la logique de boucle via une liste. Lorsque j'atteint la fin de la liste, je souhaite que l'index commence à 0 à nouveau. La liste est en cours d'exécution dans une boucle et une résiliation se produira, de sorte que ce ne sera pas une boucle infinie.
J'ai vu la solution en utilisant% opérateur, mais je ne comprends pas. Quelque chose comme ci-dessous mais avec% à la place. Je veux comprendre comment cela fonctionnera. P>
for(int i = 0; i < n; i++) {
if(i == n - 1) { i = 0; }
}
4 Réponses :
Vous pouvez faire quelque chose comme ceci: % code> vous donne le reste d'une division. P> // Will be an infinite loop
for(int i = 0; i < n; i++) {
if(i == n - 1) { i = i%(n-1); }
}
Pouvez-vous expliquer de faire cela avec% opérateur et la logique derrière elle?
Vous pouvez incrémenter le compteur de 1 et prendre le reste de celui divisé par la taille de la liste. L'opérateur Voir aussi: https://docs.oracle.com/javase/tatutorial/java/nutsandbolts/op1.html % Java prend le reste après la division après la division par un chiffre d'un numéro, A% B renvoie le reste lorsque A est divisé par b . ERGO, lorsque le compteur atteint la taille de la liste, le reste sera égal à zéro et il sera réinitialisé à 0; Lorsque le compteur est inférieur à la taille de la liste, le reste lorsqu'il est divisé par la taille sera le compteur lui-même.
the opérateur modulo donné deux nombres positifs, A et N, un% N est le reste de la division euclidienne d'un par N, où a est le dividende et n est le diviseur. p>
blockQuote> Vous avez dit que vous avez une liste, si vous utilisez % code> est le reste après une division .
% list.length () code> Cela vous donnera des valeurs de 0 à la liste.Length (). P> P> P> P> P> P> P> P> P> P > Voir le code suivant: P> element: first
element: second
element: third
element: first
element: second
element: third
element: first
element: second
element: third
element: first
package testproj;
import java.util.ArrayList;
import java.util.List;
public class ListLoop {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("string1");list.add("string2");list.add("string3");
int j=0; //loop braking.
for (int i=0;i<=list.size();i++) {
if (i == list.size()) {
i=0;
}
//This will go infinite loop. need a way to break the loop.
//Below is just demonstration.
j++;
if (j==10) break;
System.out.println("Do something with " + list.get(i));
}
}
}
Cela deviendra une boucle infinie et ne cessera jamais
J'ai une logique de terminaison en place. Ce sera dans une boucle. Comment faites-vous cela maintenant?
% est l'opérateur modulo . Il faut deux opérandes,A% B , qui indique quel montant restera si vous divisez a par b . Par exemple. 17% 5 = 2, car vous pouvez soustraire 5 de 17 pendant trois fois, puis 2 seront laissées sur 2.La chose est, si vous faites de même pour la taille de la liste , l'index "enveloppera" et sera toujours
0 <= n. Si vous devez faire une boucle infinie en la réinitialisant et utilisez une "logique de terminaison différente", votre boucle est peut-être fausse et la logique doit être modifiée.
Toute cette question ressemble à un XY Problème . Veuillez ajouter plus de contexte, comme la relation entre votre logique de terminaison et la condition de boucle actuelle.