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

Question

J'essaie de comprendre les opérateurs de quart et je ne peux pas en obtenir beaucoup. Quand 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?

Answer 1

 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. Par conséquent: 100

Answer 2

2 à partir de la virgule système de numérotation binaire est comme suit

10

maintenant, si vous ne

2 << 11

il serait , 11 zéros serait rembourrée sur le côté gauche

1000000000000

La signature de décalage à gauche de l'opérateur "<<" le travail d'une séquence de bits vers la gauche, et la signature de décalage à droite de l'opérateur ">>" l'évolution d'une séquence de bits vers la droite. La séquence 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 [..]

gauche décalage résultats dans la multiplication par 2 (*2) en termes de l'arithmétique

---

Par exemple

2 en binaire 10, si vous n' <<1 qui serait 100 qui 4

4 en binaire 100, si vous n' <<1 qui serait 1000 qui 8

---

Voir Aussi

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

Answer 3

À droite et à Gauche des quarts de travail sur le même chemin ici est de savoir Comment Décalage à Droite de travaux; Le Décalage À Droite: Le décalage à droite de l'opérateur, >>, décale tous les bits d'une valeur à la droite d'un nombre de fois spécifié. Sa forme générale:

value >> num

Ici, le nombre spécifie le nombre de positions pour le déplacement à droite de la valeur de la 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écale la valeur de 32 à droite par deux positions, résultant en un être fixée à 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écale la valeur de 35 à le droit à deux positions, ce qui provoque les deux bits de perte, résultant de nouveau dans un être fixé à 8.

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

À la recherche à la même opération en binaire montre plus clairement comment cela se passe:

00100011 35 >> 2
00001000 8

Chaque fois que vous changez une valeur à la droite, il divise cette valeur par deux et ignore le reste. Vous pouvez profiter de cette haute performance division entière par 2. Bien sûr, vous devez être sûr que vous êtes n'est pas de changer tous les bits large de l'extrémité droite. Lorsque vous êtes en déplacement à droite, en haut (à gauche) bits exposés par le décalage à droite sont remplis avec le contenu précédent de la transmission haut. Cela s'appelle l'extension du signe et sert à préserver le signe des nombres négatifs lorsque vous vous déplacer à 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 changez de -1 à droite, le résultat reste toujours -1, depuis l'extension du signe garde apportant en plus de ceux dans les bits de poids fort. 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. Notez que la valeur décalée est masqué par ANDing avec 0x0f jeter le signe étendu bits, de sorte que la valeur peut être utilisé 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 la sortie de ce programme:

b = 0xf1

Answer 4

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
 

Answer 5

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

Pour ex,

• binary 10 qui correspond à digit 2 décalé à gauche de 2 soit 1000 qui correspond à digit 8
• binary 10 qui correspond à digit 2 décalage à gauche de 3 correspond à 10000 qui correspond à digit 16