web-dev-qa-db-fra.com

Comment fonctionne le bithifting en Java?

J'ai cette déclaration:

Supposons que la valeur binaire de l'octet x vaut 00101011. Quel est le résultat de x>>2?

Comment puis-je le programmer et quelqu'un peut-il m'expliquer ce qui se passe?

javabitwise-operators
58
bentham

Premièrement, vous pouvez pas décaler un byte en Java, vous pouvez uniquement décaler un int ou un long. Ainsi, le byte fera l'objet d'une promotion en premier, par exemple.

00101011 -> 00000000000000000000000000101011

ou

11010100 -> 11111111111111111111111111010100

À présent, x >> N _ signifie (si vous l’affiche sous forme de chaîne de chiffres binaires):

  • Les N bits les plus à droite sont rejetés
  • Le bit le plus à gauche est répliqué autant de fois que nécessaire pour cadrer le résultat à la taille d'origine (32 ou 64 bits), par ex.

00000000000000000000000000101011 >> 2 -> 00000000000000000000000000001010

11111111111111111111111111010100 >> 2 -> 11111111111111111111111111110101

94
finnw

Shift Operators

Les 32 bits binaires pour 00101011 est

00000000 00000000 00000000 00101011, et le résultat est:

  00000000 00000000 00000000 00101011   >> 2(times)
 \\                                 \\
  00000000 00000000 00000000 00001010

Décale les bits de 43 à droite de la distance 2; se remplit avec le bit le plus élevé (signe) sur le côté gauche.

Le résultat est 00001010 avec la valeur décimale 10.

00001010
    8+2 = 10
57
Chandra Sekhar

Lorsque vous décalez de 2 bits vers la droite, vous supprimez les 2 bits les moins significatifs. Alors:

x = 00101011

x >> 2

// now (notice the 2 new 0's on the left of the byte)
x = 00001010

C'est essentiellement la même chose que de diviser un int par 2, 2 fois.

en Java

byte b = (byte) 16;
b = b >> 2;
// prints 4
System.out.println(b);
16
jjnguy

Ces exemples couvrent les trois types de déplacements appliqués à la fois à un nombre positif et à un nombre négatif:

// Signed left shift on 626348975
00100101010101010101001110101111 is   626348975
01001010101010101010011101011110 is  1252697950 after << 1
10010101010101010100111010111100 is -1789571396 after << 2
00101010101010101001110101111000 is   715824504 after << 3

// Signed left shift on -552270512
11011111000101010000010101010000 is  -552270512
10111110001010100000101010100000 is -1104541024 after << 1
01111100010101000001010101000000 is  2085885248 after << 2
11111000101010000010101010000000 is  -123196800 after << 3


// Signed right shift on 626348975
00100101010101010101001110101111 is   626348975
00010010101010101010100111010111 is   313174487 after >> 1
00001001010101010101010011101011 is   156587243 after >> 2
00000100101010101010101001110101 is    78293621 after >> 3

// Signed right shift on -552270512
11011111000101010000010101010000 is  -552270512
11101111100010101000001010101000 is  -276135256 after >> 1
11110111110001010100000101010100 is  -138067628 after >> 2
11111011111000101010000010101010 is   -69033814 after >> 3


// Unsigned right shift on 626348975
00100101010101010101001110101111 is   626348975
00010010101010101010100111010111 is   313174487 after >>> 1
00001001010101010101010011101011 is   156587243 after >>> 2
00000100101010101010101001110101 is    78293621 after >>> 3

// Unsigned right shift on -552270512
11011111000101010000010101010000 is  -552270512
01101111100010101000001010101000 is  1871348392 after >>> 1
00110111110001010100000101010100 is   935674196 after >>> 2
00011011111000101010000010101010 is   467837098 after >>> 3
10
Percy Vega

>> est l’opérateur Arithmetic Right Shift. Tous les bits du premier opérande sont décalés du nombre de places indiqué par le deuxième opérande. Les bits les plus à gauche du résultat ont la même valeur que le bit le plus à gauche du nombre d'origine. (C’est pour que les nombres négatifs restent négatifs.)

Voici votre cas spécifique:

00101011
  001010 <-- Shifted twice to the right (rightmost bits dropped)
00001010 <-- Leftmost bits filled with 0s (to match leftmost bit in original number)
5
Mike Daniels
public class Shift {
 public static void main(String[] args) {
  Byte b = Byte.parseByte("00101011",2);
  System.out.println(b);
  byte val = b.byteValue();
  Byte shifted = new Byte((byte) (val >> 2));
  System.out.println(shifted);

  // often overloked  are the methods of Integer

  int i = Integer.parseInt("00101011",2);
  System.out.println( Integer.toBinaryString(i));
  i >>= 2;
  System.out.println( Integer.toBinaryString(i));
 }
}

Sortie:

43
10
101011
1010
4
stacker

Vous pouvez utiliser par exemple cette API si vous souhaitez voir la présentation de vos numéros par bitString. mathématiques peu communes

Exemple (en jubile)

bitString = org.uncommons.maths.binary.BitString.new(Java.math.BigInteger.new("12").toString(2))
bitString.setBit(1, true)
bitString.toNumber => 14

edit : lien API modifié et ajout d'un petit exemple

2
Joni
byte x = 51; //00101011
byte y = (byte) (x >> 2); //00001010 aka Base(10) 10
2
Jacob Tomaw

Vous ne pouvez pas écrire de littéraux binaires comme 00101011 in Java afin que vous puissiez l'écrire au format hexadécimal à la place:

byte x = 0x2b;

Pour calculer le résultat de x >> 2 vous pouvez alors écrire exactement cela et imprimer le résultat.

System.out.println(x >> 2);
2
Mark Byers

00101011 = 43 en décimal

class test {    
    public static void main(String[] args){
       int a= 43;       
       String b= Integer.toBinaryString(a >> 2);        
       System.out.println(b);
    }   
}

Sortie:

101011 devient 1010

0
Gihan Fernando