Comment ai-je pu l'indice d'un tableau de "roulement" lors de l'incrémentation?

Donc, j'ai un Tableau avec une longueur de 4. Quand je l'incrémente de 1 et le nombre est plus grand que la longueur de la matrice, j'aimerais qu'il rollover.

Par exemple:

current_index = 3;
current_index++;
//current_index is now 0 again

current_index = 3;
current_index += 2;
//current_index would be 1

current_index = 0;
current_index--;
//current_index would be 3

Je suis en train de le résoudre avec des if-else, comme ce

if (current_index == textviewlist.length + 1)
     current_index = 0;
else if (current_index == textviewlist.length + 2)
     current_index = 1;
else if (current_index == -1)
     current_index = 3;

Mais je sens que ce n'est pas une solution appropriée, ou "bon" code.

Modifier: j'ai essayé ta suggestion, mais apparemment, java se comporte de façon étrange avec des nombres négatifs.
Lorsque j'essaie

current_index = (current_index - 1) % textviewlist.length;

Java prend l'indice "0", il diminue de 1 ("-1") et puis

 -1 % 4 = -1

Je m'attendais à 3, voir Wolfram Alpha: -1 mod 4
Mais apparemment, la java % de l'opérateur n'est pas la même que l'opérateur modulo?

Edit 2: j'ai trouvé une solution ici: La meilleure façon de faire de Java module se comporter comme il se doit avec des nombres négatifs? - Débordement De Pile

Que je peux le faire:

current_index -= 1;
current_index = (current_index % textviewlist.length + textviewlist.length)  % textviewlist.length;

InformationsquelleAutor intagli | 2011-07-26

8

Vous pouvez utiliser l'opérateur modulo.
```
current_index = (current_index + n) % 4;
```
- Merci beaucoup pour votre réponse. +1 🙂
- Parce que google classe cette page le plus élevé lors de la recherche de la même chose, mais en JavaScript voici le JS version: current_index = (current_index + n + 4) % 4;
- Le commentaire ci-dessus est #fakenews
InformationsquelleAutor Karoly Horvath
4

Vous pouvez utiliser le mod comme suit:
```
current_index = (current_index + i) % 4.
```
- Merci beaucoup, je savais qu'il me manquait quelque chose.
InformationsquelleAutor eugene_che
3

Diviser l'indice incrémenté modulo la longueur du tableau:
```
current_index = (current_index + n) % textviewlist.length
```
- Merci beaucoup, j'ai raté la forêt pour les arbres...
InformationsquelleAutor Xion
2

Il suffit de le régler à lui-même modulo 4 - ou plutôt, la longueur de la liste après chaque incrément.
```
current_index += 2;
current_index %= textviewlist.length;
```
ou de façon combinée:
```
current_index = (current_index + 2) % textviewlist.length;
```
Vous pourriez aussi le faire:
```
current_index += n;
while (current_index >= textviewlist.length) {
    current_index -= textviewlist.length;
}
```
bien que je serais surpris si ce n'est pas plus lent que le modulo, surtout depuis votre liste de longueur est une puissance de 2.

De toute façon, il pourrait être une bonne idée d'encapsuler tout cela dans un increment() fonction:
```
int increment(int old_index, int n) {
    return (old_index + n) % textviewlist.length;
}
```
EDIT: ah, je ne savais pas que vous étiez de travail en Java. (Je pense que C de l'opérateur modulo imite la définition mathématique sur les nombres négatifs) d'Une légère amélioration sur la solution que vous avez trouvé serait
```
int increment(int old_index, int n) {
    return (old_index + n + textviewlist.length) % textviewlist.length;
}
```
- Merci pour votre réponse, j'aime bien l'idée d'un increment() fonction. Cependant, ce qui se passe avec des valeurs négatives? J'ai juste modifié ma question pour refléter cela.
- Crois que j'ai trouvé une solution..
InformationsquelleAutor David Z

Vous devez vous connecter pour publier un commentaire.