Comment fonctionnent les opérateurs de shift en Java? [dupliquer]

2 du système de numérotation décimale en binaire est comme suit

10

maintenant, si vous ne

2 << 11

il serait , 11 zéros seraient capitonnés sur le côté droit

1000000000000

l'opérateur de poste de gauche signé "< < " déplace un patron de bits vers la gauche, et l'opérateur de poste de droite signé ">>" déplace un patron de bit vers la droite. Le motif de bits est donné par l'opérande de gauche, et le nombre de positions à déplacer par l'opérande de droite. L'opérateur de poste de droite non signé "> > > "déplace un zéro dans la position la plus à gauche, tandis que la position la plus à gauche après" > > "dépend de l'extension du signal [..]

à gauche en déplaçant les résultats dans la multiplication par 2 (*2) ou de l'arithmétique

par exemple

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

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

Voir Aussi

• absolu-débutants-guide-de-décalage de bits

travail posté à droite et à gauche de la même façon voici comment fonctionne le travail posté à droite; Le Décalage À Droite: L'opérateur de décalage de droite,>>, déplace tous les bits d'une valeur vers la droite un nombre spécifié de fois. Sa forme générale:

value >> num

ici, le num spécifie le nombre de positions pour décaler vers la droite la valeur en valeur. Qui est, le >> décale tous les bits de la valeur spécifiée à droite le nombre de positions de bits spécifié par num. Le fragment de code suivant déplace la valeur 32 vers la droite de deux positions, ce qui donne une valeur 8:

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

Lorsqu'une valeur a de bits qui sont "décalés", ces bits sont perdus. Par exemple, le fragment de code suivant déplace la valeur 35 vers les deux positions de droite, ce qui provoque la perte des deux bits de bas ordre, ce qui entraîne à nouveau un réglage à 8.

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

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éplacez une valeur vers la droite, elle divise cette valeur par deux-et écarte tout reste. Vous pouvez en profiter pour la division entière de haute performance par 2. Bien sûr, vous devez être sûr que vous ne déplacez pas de bits sur le bon bout. Lorsque vous déplacez vers la droite, les bits supérieurs (gauches) exposés par le décalage droit sont remplis avec le contenu précédent du bit supérieur. Ceci est appelé extension de signe et sert à préserver le signe de négatif les nombres quand vous les déplacez à droite. Par exemple, –8 >> 1 est –4 , 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, puisque l'extension du signe n'arrête pas d'en amener plus dans les bits de haut ordre. Parfois, il n'est pas souhaitable de s'inscrire étendre les valeurs lorsque vous déplaçant vers la droite. Par exemple, le programme suivant convertit une valeur d'un octet à sa représentation de chaîne hexadécimale. Remarquez que la valeur décalée est masquée par un ANDing avec 0x0f pour écarter tout bit étendu par un signe de sorte que la valeur puisse être utilisée comme un 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

je crois que ça 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 Ce (comment-faire-le-bit-à-bit-maj-opérateurs-travail)

je pense que ce serait le suivant, par exemple:

• poste de gauche signé

[ 2 << 1 ] is => [10 (binaire de 2) Ajouter 1 zéro à la fin de la chaîne binaire] donc 10 sera 100 qui devient 4.

Signé maj gauche utilise la multiplication... Donc, cela pourrait aussi être calculé comme suit: 2 * (2^1) = 4. Un autre exemple [ 2 << 11] = 2 *(2^11) = 4096

• poste de droite signé

[ 4 >> 1 ] est => [100 (binaire de 4) enlever 1 zéro à la fin de la chaîne binaire] 100 10 qui devient 2.

le quart de droite utilise la division... Ceci pourrait donc être calculé comme 4 / (2^1) = 2 Un autre exemple [ 4096 >> 11] = 4096 / (2^11) = 2

il déplacera les bits par rembourrage que beaucoup 0's .

pour ex,

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

le shift peut être implémenté avec des types de données (char, int et long int). Le flotteur et le double connot de données doivent être déplacés.

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

poste signé à gauche Logiquement Simple si 1 < < 11 Il tend à 2048 et 2< < 11 donnera 4096

en programmation java int a = 2 < < 11;

// it will result in 4096

2<<11 = 2*(2^11) = 4096

l'usage typique de déplacer une variable et d'attribuer de nouveau à la variable peut être réécrit avec des opérateurs de sténographie <<= , >>= , ou >>>= , également connu dans la spécification comme opérateurs D'assignation de composé .

par exemple,

i >>= 2

produit le même résultat que

i = i >> 2