java de manipulation de bits

byte x = -1;
for(int i = 0; i < 8; i++)
{
    x = (byte) (x >>> 1);
    System.out.println("X: " + x);
}

Comme je le comprends, java stocke les données en complément à deux, sens -1 = 11111111 (selon wikipedia).

Aussi, à partir de la java docs:
"Le modèle de bits est donnée par la gauche opérande, et le nombre de postes à changement de la partie droite de l'opérande. La unsigned décalage à droite de l'opérateur ">>>" l'évolution d'un zéro dans la position la plus à gauche, tandis que la position la plus à gauche après ">>" dépend de l'extension du signe. "

Ce qui signifie qu' >>> décalera d'un 0 à gauche de la plupart des bits à chaque fois. J'attends donc ce code à

itération: représentation binaire de x

0: 11111111

1: 01111111

2: 00111111

3: 00011111

...etc

Cependant, ma sortie est toujours X: -1, sens (je suppose) que >>> est de mettre le bit de signe dans la plus à gauche de la position. J'ai donc essayer >>, et même résultat.

Ce qu'il se passe? Je m'attends à ma sortie: X: -1, x: 127, x: 63, etc.

C'est l'un des problèmes en Java casse-têtes.

OriginalL'auteur jbu | 2009-02-19

27

Celui qui pense que les octets doit être signé lors de Java a été inventé et a battu avec un wet bâton de céleri jusqu'à ce qu'ils crient 🙂

Vous pouvez faire ce que vous voulez par la coulée jusqu'à un int et en veillant à ne jamais déplacer un 1 dans le top peu, quelque chose comme ceci:
```
byte x = -1;
int x2 = ((int)x) & 0xff;
for(int i = 0; i < 8; i++)
{
    x2 = (x2 >>> 1);
    System.out.println("X: " + x2);
}
```
Votre problème particulier est parce que >>> est coulée en place d'un int pour faire le passage, alors vous êtes de la coulée dans un octet, comme illustré ici:
```
byte x = -1;
int x2 = ((int)x) & 0xff;
int x3;
int x4 = x2;
for(int i = 0; i < 8; i++)
{
    x2 = (x2 >>> 1);
    System.out.println("X2: " + x2);
    x3 = (x >>> 1);
    x = (byte)x3;
    x4 = (x4 >>> 1);
    System.out.println("X: " + x3 + " " + x + " " + x4);
}
```
Sorties:
```
X2: 127
X: 2147483647 -1 127
X2: 63
X: 2147483647 -1 63
X2: 31
X: 2147483647 -1 31
X2: 15
X: 2147483647 -1 15
X2: 7
X: 2147483647 -1 7
X2: 3
X: 2147483647 -1 3
X2: 1
X: 2147483647 -1 1
X2: 0
X: 2147483647 -1 0
```
Vous pouvez clairement voir que x et x3 ne fonctionnent pas (même si x3 déplace correctement, moulage retour à l'octet dans x il met à -1). x4 fonctionne parfaitement.

bien que cela fonctionne (j'apprécie l'aide) il ne veut pas m'expliquer pourquoi mon code ne fonctionne pas.
Voir mise à jour qui l'explique mieux.
Oui, c'est fait, merci!
+1 pour le céleri commentaire. Je n'ai jamais encore eu une situation où je veux un octet signé....

OriginalL'auteur paxdiablo
5

Rappelez-vous que:
- opérandes de des opérations bit à bit sont toujours promu au moins un int!
- jette toujours impliquer l'extension du signe.
Ainsi quand vous n' (x >>> n), même si vous avez défini x octet, pour l'application de la maj, il va d'abord être converti en int. Si l'octet converti est négative, alors tous les "extra" (donc, le plus à gauche 24 bits de l'résultant int) a été ajoutée à le faire jusqu'à un int sera fixé à 1. Ou mettre une autre manière, si le premier octet est -1, la chose que vous êtes réellement le déplacement est -1 comme int, c'est à dire nombre de 32 bits à 32 bits mis à 1. Le passage de ce droit par 1-8 endroits sera toujours dans le fond de 8 bits tous mis à 1, donc lorsque vous lancez un retour à un octet, vous vous retrouvez avec un octet avec toutes les 8 bits mis à 1, ou, en d'autres termes, un octet de valeur de -1.

OriginalL'auteur Neil Coffey
3

Je ne suis pas sûr à ce sujet. Mais, je suppose que
```
x >>> 1 
```
sera promu à un int à partir de l'octet, parce que le littéral "1" est un int. Ensuite, ce que vous observez de sens.

Je ne le pense pas.. j'ai changé le code pour s'assurer qu'il n'était pas à obtenir une promotion à un int: byte x = -1; for(int i = 0; i < 8; i++) { x = (byte) ((byte)x >> (octet)1); le Système..println("X:" + x); } le résultat était le même, X: -1 à chaque fois
Cela n'aide pas - bien sûr, vous convertir x et de 1 à octets, mais Java automatiquement convertit à ints avant l'application de l'opérateur de décalage à droite. Il n'y a aucun moyen d'appliquer directement un décalage de bit d'octets, pour autant que je sais.

OriginalL'auteur Himadri Choudhury
0

Je ne sais pas pourquoi ça ne fonctionne pas, mais un moyen facile de dégager le dessus est de & (binaire) 0111111:
```
x = (byte) (x >>> 1) & 0x7F;
```
OriginalL'auteur Jacob Krall
0

Le problème est, comme l'a dit avant (il ya longtemps), que x obtenir upcasted à int (signe étendu) avant de faire la maj.

Faire un "bit-à-bit" conversion devrait aider:
```
byte x = -1;
for(int i = 0; i < 8; i++)
{
    x = (byte) ((x & 0xFF) >>> 1);
    System.out.println("X: " + x);
}
```
serait bon de savoir pourquoi l'-1 ...

OriginalL'auteur Carlos Heuberger

Vous devez vous connecter pour publier un commentaire.