Comment bitshifting travail en Java?

J'ai cette déclaration:

Assumer la valeur de bit de l'octet x est 00101011. quel est le résultat de x>>2?

Comment puis-je programmer et quelqu'un peut-il m'expliquer ce qui est en train de faire?

InformationsquelleAutor bentham | 2010-07-22
  1. 92

    Tout d'abord, vous pouvez pas maj un byte en java, vous ne pouvez déplacer une int ou un long. Ainsi, le byte subir la promotion de la première, par exemple,

    00101011 -> 00000000000000000000000000101011

    ou

    11010100 -> 11111111111111111111111111010100

    Maintenant, x >> N signifie (si vous l'avez vue comme une chaîne de chiffres binaires):

    • Les N bits les plus à droite sont jetés
    • Bit le plus à gauche est reproduit autant de fois que nécessaire pour ajouter le résultat à la taille d'origine (32 ou 64 bits), par exemple

    00000000000000000000000000101011 >> 2 -> 00000000000000000000000000001010

    11111111111111111111111111010100 >> 2 -> 11111111111111111111111111110101

    • Serait 11010100 être considéré comme un nombre négatif car il est le plus à gauche bit est à 1? \
    • oui, en supposant que le numéro est stocké dans le complément de 2. Voir stackoverflow.com/questions/1049722/what-is-2s-complement.
    • J'ai essayé de déplacement int en java à l'aide d': @Test public void testBinaryString() { int n = 4; int v = n >> 1; Système.out.println("v =" + v + "n =" + n); } Mais je reçois de sortie: v = 2, n = 4. Vous vous demandez pourquoi il ne change pas de n à 2?
    InformationsquelleAutor finnw
  2. 55

    Comment bitshifting travail en Java?

    Les binaires 32 bits 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 par une distance de 2; remplit avec le plus haut(signe) bit sur le côté gauche.

    Résultat est 00001010 avec la valeur décimale 10.

    00001010
    8+2 = 10
    InformationsquelleAutor Chandra Sekhar
  3. 16

    Lorsque vous changez de droit 2 bits vous déposez les 2 bits de poids faible. Donc:

    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 diviser un entier par 2, 2 fois.

    En Java

    byte b = (byte) 16;
b = b >> 2;
//prints 4
System.out.println(b);
    • Chaque maj de droite est de diviser par 2, donc deux quarts de travail est de diviser par 4.
    • Exactement. Ou, en mathématiques speek: n >> m -> n / (2^m)
    • yup, mais qui semble effrayant.
    • Peut-être un peu plus clair si vous vous montrez le rembourrage des 0 à gauche après la bitshift.
    • merci, a ajouté
    • Vous ne pouvez pas le faire au niveau du bit opérations de décalage sur byte type de données dans le langage de programmation Java.

    InformationsquelleAutor jjnguy
  4. 10

    Ces exemples couvrent les trois types de changements appliqués à la fois 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
    InformationsquelleAutor Percy Vega
  5. 5

    >> est la moyenne Décalage à Droite de l'opérateur. Tous les bits dans le premier opérande sont décalés, le nombre de places indiqué par le deuxième opérande. Le plus à gauche des bits dans le résultat sont définis sur la même valeur que le bit plus à gauche dans le numéro d'origine. (C'est ainsi que les nombres négatifs restent négatives.)

    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)
    InformationsquelleAutor Mike Daniels
  6. 4
    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));
 }
}

    De sortie:

    43
10
101011
1010
    InformationsquelleAutor stacker
  7. 2
    byte x = 51; //00101011
byte y = (byte) (x >> 2); //00001010 aka Base(10) 10
    InformationsquelleAutor Jacob Tomaw
  8. 2

    Vous ne pouvez pas écrire en binaire littéraux comme 00101011 en Java, de sorte que vous pouvez l'écrire en hexadécimal à la place:

    byte x = 0x2b;

    Pour calculer le résultat de x >> 2 vous pouvez ensuite il suffit d'écrire exactement ce que et imprimer le résultat.

    System.out.println(x >> 2);
    • ce qui est sur un Octet.parseByte("00101011",2); ?
    • Est-ce calculé au moment de la compilation ou faut-il le résultat d'un appel de méthode au moment de l'exécution?
    • Java 7 devrait être l'ajout d'binaire littéraux, par exemple: 0b00101011
    • Kreuger: C'est une excellente nouvelle. 🙂 Merci pour l'info.
    InformationsquelleAutor Mark Byers
  9. 2

    Vous pouvez utiliser, par exemple, cette API si vous souhaitez voir bitString présentation de vos numéros. Uncommons Mathématiques

    Exemple (en jruby)

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

    modifier: changement d'api lien et ajouter un peu d'exemple

    • L'URL mentionnée ci-dessus est mort. Veuillez supprimer/éditer pour le point à droite de la page web.
    • Lien mis à jour. Je ne sais pas si cela répond que modifiée question plus que ..
    • Vous avez enregistré la requête HTTP avec un mort URL!
    InformationsquelleAutor Joni
  10. 0

    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);
    }   
}

    De sortie:

    101011 devient 1010

    • Pouvez-vous préciser ce qui distingue cette réponse de la part des autres posté ici?
    InformationsquelleAutor Gihan Fernando