web-dev-qa-db-fra.com

Comment les opérateurs de travail travaillent-ils en Java?

J'essaie de comprendre les opérateurs de quart de travail et je ne pouvais pas en obtenir beaucoup .. lorsque j'ai essayé d'exécuter le code ci-dessous

System.out.println(Integer.toBinaryString(2 << 11));
System.out.println(Integer.toBinaryString(2 << 22));
System.out.println(Integer.toBinaryString(2 << 33));
System.out.println(Integer.toBinaryString(2 << 44));
System.out.println(Integer.toBinaryString(2 << 55));

Je reçois le dessous

1000000000000    
100000000000000000000000    
100    
10000000000000    
1000000000000000000000000

Quelqu'un pourrait-il s'il vous plaît expliquer?

javabit-shift
126
gnreddy
System.out.println(Integer.toBinaryString(2 << 11));

Décale le binaire 2 (10) de 11 fois vers la gauche. D'où: 1000000000000

System.out.println(Integer.toBinaryString(2 << 22));

Décale le binaire 2 (10) de 22 fois vers la gauche. D'où: 100000000000000000000000

System.out.println(Integer.toBinaryString(2 << 33));

Maintenant, int est de 4 octets, donc 32 bits. Ainsi, lorsque vous effectuez un décalage de 33, cela équivaut à un décalage de 1. Ainsi: 100

194
Kazekage Gaara

2 du système de numérotation décimale en binaire est la suivante

10

maintenant si tu le fais 

2 << 11

ce serait, 11 zéros seraient rembourrés sur le côté droit

1000000000000

L'opérateur de décalage gauche signé "<<" décale un motif binaire vers la gauche et l'opérateur de décalage droit signé ">>" décale le motif binaire vers la droite. La configuration de bits est donnée par l'opérande de gauche et le nombre de positions à déplacer par l'opérande de droite. L'opérateur de décalage droit non signé ">>>" décale le zéro dans la position la plus à gauche, tandis que la position la plus à gauche après ">>" dépend de l'extension du signe [..]

décalage gauche entraîne la multiplication par 2 (* 2) en termes ou arithmétique

Par exemple 

2 en binaire 10, si vous faites <<1 ce serait 100 qui est 4 

4 en binaire 100, si vous faites <<1, ce serait 1000 qui est 8

Regarde aussi

33
Jigar Joshi

Les décalages droit et gauche fonctionnent de la même manière. Voici comment fonctionne le décalage droit; Le décalage droit: L'opérateur de décalage droit, >> décale tous les bits d'une valeur vers la droite d'un nombre spécifié de fois. Sa forme générale:

value >> num

Ici, num spécifie le nombre de positions pour déplacer à droite la valeur en valeur. En d'autres termes, le >> déplace tous les bits de la valeur spécifiée vers la droite du nombre de positions de bits spécifié par num . Le fragment de code suivant décale la valeur 32 de deux positions vers la droite, ce qui entraîne la définition d'un paramètre. à 8:

int a = 32;
a = a >> 2; // a now contains 8

Lorsqu'une valeur comporte des bits «décalés», ces bits sont perdus. Par exemple, le fragment de code suivant décale la valeur 35 des deux positions de droite, ce qui entraîne la perte des deux bits de poids faible, ce qui entraîne à nouveau la définition de 8.

int a = 35;
a = a >> 2; // a still contains 8

Le fait de regarder la même opération en binaire montre plus clairement comment cela se produit:

00100011 35 >> 2
00001000 8

Chaque fois que vous décalez une valeur vers la droite, elle est divisée par deux et élimine le reste. Vous pouvez en tirer parti pour une division entière hautes performances par 2. Bien sûr, vous devez vous assurer de ne pas décaler de bits de l'extrémité droite . Lorsque vous effectuez un décalage à droite, les bits les plus supérieurs (les plus à gauche) sont exposés. par le décalage à droite sont remplis avec le contenu précédent du bit supérieur. Cela s'appelle extension de signe et sert à préserver le signe des nombres négatifs lorsque vous les déplacez vers la droite. Par exemple, –8 >> 1 est –4, ce qui, en binaire, est

11111000 –8 >>1
11111100 –4

Il est intéressant de noter que si vous décalez –1 à droite, le résultat reste toujours –1, car l'extension de signe continue d'en ajouter de plus dans les bits de poids fort . Parfois, il n'est pas souhaitable de les décalent vers la droite. Par exemple, le programme suivant convertit une valeur d'octet en une représentation sous forme de chaîne hexadécimale. Notez que la valeur décalée est masquée en utilisant AND avec 0x0f pour ignorer tous les bits étendus de signe afin que la valeur puisse être utilisée comme index dans le tableau de caractères hexadécimaux.

// Masking sign extension.
class HexByte {
  static public void main(String args[]) {
    char hex[] = {
      '0', '1', '2', '3', '4', '5', '6', '7',
      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
    };
  byte b = (byte) 0xf1;
 System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
}
}

Voici le résultat de ce programme:

b = 0xf1
14
star18bit

Je crois que cela pourrait aider:

    System.out.println(Integer.toBinaryString(2 << 0));
    System.out.println(Integer.toBinaryString(2 << 1));
    System.out.println(Integer.toBinaryString(2 << 2));
    System.out.println(Integer.toBinaryString(2 << 3));
    System.out.println(Integer.toBinaryString(2 << 4));
    System.out.println(Integer.toBinaryString(2 << 5));

Résultat

    10
    100
    1000
    10000
    100000
    1000000

Édité:

Doit lire ceci (comment-faire-le-bit-shift-operateurs-travail)

12
Khaja Md Sher E Alam

Je pense que ce serait le suivant, par exemple:

  • Décalé à gauche

[2 << 1] est => [10 (nombre binaire de 2) additionner 1 zéro à la fin de la chaîne binaire] Donc 10 sera 100, ce qui donne 4.

Le décalage gauche signé utilise la multiplication ... Cela pourrait donc aussi être calculé comme suit: 2 * (2 ^ 1) = 4 . Un autre exemple [2 << 11] = 2 * (2 ^ 11) = 4096 

  • Signé décalage à droite

[4 >> 1] est => [100 (binaire de 4) supprime 1 zéro à la fin de la chaîne binaire] Donc 100 sera égal à 10, ce qui donne 2.

Le décalage de droite signé utilise la division ... Cela pourrait donc aussi être calculé comme suit: 4/(2 ^ 1) = 2 Un autre exemple [4096 >> 11] = 4096/( 2 ^ 11) = 2

7
Obothlale

Cela décale les bits en ajoutant autant de 0's.

Pour ex, 

  • binaire 10 qui est le chiffre 2 décalage à gauche de 2 est 1000 qui est le chiffre 8
  • binaire 10 qui est le chiffre 2 décalage à gauche de 3 est 10000 qui est le chiffre 16
2
Ramesh PVK

Le décalage peut être implémenté avec des types de données (char, int et long int). Les données flottantes et doubles ne peuvent pas être déplacées. 

value= value >> steps  // Right shift, signed data.
value= value << steps  // Left shift, signed data.
2
Student

Signé décalage gauche Logiquement Simple si 1 << 11 il aura tendance à 2048 et 2 << 11 donnera 4096 

En programmation Java int a = 2 << 11;

// it will result in 4096

2<<11 = 2*(2^11) = 4096
1
sunil rana

L’utilisation typique du décalage d’une variable et de l’affectation de cette variable peut être réécrite avec les opérateurs de raccourci << =, >> = ou >>> =, également dans la spécification en tant que Opérateurs d'assignation composés .

Par exemple,

i >>= 2

produit le même résultat que

i = i >> 2
0
Nicholas Sushkin