Comment fonctionne le Bitwise & (AND) en Java?
je lisais quelques exemples de code et je suis tombé sur un & sur le site D'Oracle sur leur page opérateurs de changement de bit et Bitwise. À mon avis, il n'a pas fait trop bien d'un travail expliquant le bitwise &. Je comprends qu'il fait une opération directement au bit, mais je ne suis pas sûr de quel type d'opération, et je me demande ce que cette opération est. Voici un exemple de programme que J'ai trouvé sur le site D'Oracle: http://docs.oracle.com/javase/tutorial/displayCode.html?code=http://docs.oracle.com/javase/tutorial/java/nutsandbolts/examples/BitDemo.java
6 réponses
un entier est représenté comme une séquence de bits en mémoire. Pour l'interaction avec les humains, l'ordinateur doit afficher que les chiffres après la virgule, mais tous les calculs sont effectués sous forme binaire. 123 en décimal est stocké comme 1111011 dans la mémoire.
& l'opérateur est un bitwise "et". Le résultat est les bits qui sont activés dans les deux nombres. 1001 & 1100 = 1000, puisque seul le premier bit est activé sur les deux.
| l'opérateur est un "ou"bitwise. Le résultat est les bits qui sont activés qu'en soit le nombre. 1001 | 1100 = 1101, puisque seul le second bit de droite est zéro dans les deux.
Il y a aussi le ^ et ~ opérateurs, qui sont respectivement "Xor" et "Not" bitwise. Enfin il y a le <<,>> et >>> opérateurs de décalage.
Sous le capot, 123 est stocké sur 01111011 00000000 00000000 00000000 ou 00000000 00000000 00000000 01111011 selon le système. En utilisant les opérateurs bitwise, qui la représentation n'a pas d'importance, puisque les deux représentations sont traitées comme le nombre logique 00000000000000000000000001111011. Le dépouiller de zéros feuilles 1111011.
c'est un binaire et un opérateur. Il effectue une opération qui fait partie de Logique Booléenne qui est couramment utilisé sur les nombres binaires dans le calcul.
Par exemple:
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
vous pouvez également effectuer cela sur des nombres à bits multiples:
01 & 00 = 00
11 & 00 = 00
11 & 01 = 01
1111 & 0101 = 0101
11111111 & 01101101 = 01101101
...
si vous regardez deux nombres représentés en binaire, un bitwise & crée un troisième nombre qui a un 1 à chaque endroit que les deux nombres ont un 1. (Partout ailleurs il y a des zéros).
Exemple:0b10011011 &0b10100010 =0b10000010
notez que ceux-ci n'apparaissent que lorsque les deux arguments en ont un à cet endroit.
Au niveau du bit les padn sont utiles lorsque chaque morceau d'un nombre stocke un élément d'information spécifique.
Vous pouvez également les utiliser pour supprimer, extraire certaines sections de nombres en utilisant les masques.
si vous développez les deux variables selon leur code hexadécimal, ce sont:
bitmask : 0000 0000 0000 1111
val: 0010 0010 0010 0010
maintenant, un simple bitwise et l'opération se traduit par le nombre 0000 0000 0000 0010, qui en unités décimales est 2. Je suppose que vous êtes au courant des opérations booléennes fondamentales et des systèmes de nombres.
Sa une opération logique sur les valeurs d'entrée. Pour comprendre convertir les valeurs en la forme binaire et où bot bits en position n 1 le résultat est un 1. À la fin convertissez en arrière.
Par exemple avec ces valeurs d'exemple:
0x2222 = 10001000100010
0x000F = 00000000001111
result = 00000000000010 => 0x0002 or just 2
import.java.io.*;
import.java.util.*;
public class Test {
public static void main(String[] args) {
int rmv,rmv1;
//this R.M.VIVEK complete bitwise program for java
Scanner vivek=new Scanner();
System.out.println("ENTER THE X value");
rmv = vivek.nextInt();
System.out.println("ENTER THE y value");
rmv1 = vivek.nextInt();
System.out.println("AND table based\t(&)rmv=%d,vivek=%d=%d\n",rmv,rmv1,rmv&rmv1);//11=1,10=0
System.out.println("OR table based\t(&)rmv=%d,vivek=%d=%d\n",rmv,rmv1,rmv|rmv1);//10=1,00=0
System.out.println("xOR table based\t(&)rmv=%d,vivek=%d=%d\n",rmv,rmv1,rmv^rmv1);
System.out.println("LEFT SWITH based to %d>>4=%d\n",rmv<<4);
System.out.println("RIGTH SWITH based to %d>>2=%d\n",rmv>>2);
for(int v=1;v<=10;v++)
System.out.println("LIFT SWITH based to (-NAGATIVE VALUE) -1<<%d=%p\n",i,-1<<1+i);
}
}