二进制以及位运算-阿里云开发者社区

|、&、||、&&、^符号含义

|和&为计算机中二进制之间的位运算

在计算机中二进制的0表示false，1表示true。

|为位运算中的或运算：它的运算逻辑为一真则真，全假则假

&为位运算中的并运算：它的运算逻辑为一假则假，全真则真

||和&&为计算机中的逻辑运算符

||表示为或运算：它的运算逻辑为只要一个为true则结果为true

&&表示为并运算：它的运算逻辑为全为true时结果才为true，类似于and，只有两边结果都为true时，最后结果才为true

^为计算机中的异或运算

int x=1;

int y=2;

x^=y;//异或运算，相同为0不同为1。结果为3.

System.out.println("x="+ ++x);

二进制运算过程：

0 0 0 1

0 0 1 0

--------------

0 0 1 1

最后在执行++x，所以最后输出为4。

Java中打印二进制

1. import java.util.Scanner;
2. public class Main {
3. public static void main(String[] args) {
4. System.out.println("Java二进制-7: "+Integer.toBinaryString(7));
5. System.out.println("Java二进制-7: "+Integer.toBinaryString(-7));
6.     }
7. 
8. }

Java二进制-7: 111

Java二进制-7: 11111111111111111111111111111001

其他进制打印

1. public class Main {
2. 
3. public static void main(String[] args) {
4. System.out.println(Integer.toString(45,3));//45是十进制数,3是多少进制
5. 
6.     }
7. 
8. }

负数的二进制(即正数的补码)

先举个正确的例子：

7的二进制形式可以表示如下：

00000000 00000000 00000000 00000111

-7的二进制形式可以表示如下：

11111111 11111111 11111111 11111001

1）左边为高位，右边为低位；

2）最高位为符号位，正数的符号位为0，负数的符号位为1；

3）按照我们正常的逻辑很容易想到只需要把正数7的二进制形式的符号位换成1，-7的二进制表示形式应该是

10000000 00000000 00000000 00000111

但它只是一个原码，不是最终表示形式，所以是不对的；

4）在计算机中，负数以原码的补码形式表达。要想正确推出负数的二进制表示形式，需要先了解以下基本概念

基本概念

原码

一个正数，按照其本身大小转换成的二进制数，称为原码

一个负数，按照其绝对值大小转换成的二进制数，最高位补1，称为原码

比如：

1. 00000000 00000000 00000000 00000111 // 是7的原码
2. 10000000 00000000 00000000 00000111 // 是-7的原码

反码

正数的反码与原码相同

负数的反码为对该数的原码除符号位外各位取反

比如：

1. 00000000 00000000 00000000 00000111 // 是7的反码，和原码相同
2. 10000000 00000000 00000000 00000111 // 是-7的原码
3. 11111111 11111111 11111111 11111000 // 对-7的原码取反（除符号位），即得到了-7的反码

补码

正数的补码与原码相同

负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1；即对负数的补码为对该数的反码的最后一位加1

比如：

1. 00000000 00000000 00000000 00000111 // 是7的补码，和原码相同
2. 10000000 00000000 00000000 00000111 // 是-7的原码
3. 11111111 11111111 11111111 11111000 // 对-7的原码取反（除符号位），即得到了-7的反码
4. 11111111 11111111 11111111 11111001 // 最后一位加1，即得到-7的补码，这也是负数在计算机中最终的表示形式

Java中的>>和>>>

'>>' 算术右移，向右移左边补符号位

'>>>' 逻辑右移，向右移左边补0

System.out.println("Java二进制-7: "+Integer.toBinaryString(-7));

System.out.println("-7>>2: "+Integer.toBinaryString(-7>>2));

System.out.println("-7>>>2: "+Integer.toBinaryString(-7>>>2));

输出：

Java二进制-7: 11111111111111111111111111111001

-7>>2: 11111111111111111111111111111110

-7>>>2: 111111111111111111111111111110 //正常应该这样(00)111111111111111111111111111110左边的两个0不显示

如何找数组中唯一成对的那个数

1. import java.sql.Array;
2. import java.util.Arrays;
3. import java.util.Random;
4. public class Main {
5. public static void main(String[] args) {
6. int N=11;
7. int[] arr=new int[N];
8. for(int i=0;i<arr.length-1;i++){
9.     arr[i]=i+1;
10. }
11. arr[arr.length-1]=new Random().nextInt(N-1)+1;
12. int index=new Random().nextInt(N);
13. int t=arr[arr.length-1];
14. arr[arr.length-1]=arr[index];
15. arr[index]=t;
16.         System.out.println(Arrays.toString(arr));
17. int x1=0;
18. for(int i=1;i<=N-1;i++){
19.     x1=(x1^i);
20. }
21. for(int i=0;i<N;i++){
22.     x1=x1^arr[i];
23. }
24.         System.out.println(x1);
25. 
26. 
27.     }
28. 
29. 
30. }

二进制中1的个数

1. import java.util.Scanner;
2. public class Main {
3. public static void main(String[] args) {
4.        Scanner sc=new Scanner(System.in);
5. int N=sc.nextInt();
6.         System.out.println(Integer.toString(N,2));//打印几进制
7. int count=0;
8. for(int i=0;i<32;i++){
9. if((N&1<<i)==(1<<i)){
10.         count++;
11.     }
12. }
13. 
14.         System.out.println(count);
15. 
16. 
17.     }
18. 
19. 
20. }

1. import java.util.Scanner;
2. public class Main {
3. public static void main(String[] args) {
4.        Scanner sc=new Scanner(System.in);
5. int N=sc.nextInt();
6.         System.out.println(Integer.toString(N,2));//打印几进制
7. int count=0;
8. while(N!=0){
9.     N=(N-1)&N;
10.     count++;
11. }
12. 
13. 
14.         System.out.println(count);
15. 
16. 
17.     }
18. 
19. 
20. }

1. import java.util.Scanner;
2. public class Main {
3. 
4. 
5. public static void main(String[] args) {
6.        Scanner sc=new Scanner(System.in);
7. int n= sc.nextInt();
8. while(n-->0){
9. int k= sc.nextInt();
10. int cnt=0;
11. while(k!=0){
12.                k=k&(k-1);
13.                cnt++;
14. 
15.            }
16.            System.out.print(cnt);
17. if(n!=0) System.out.print(" ");
18. 
19.        }
20. 
21.     }
22. }

用一句整数判断一个整数是不是2的整数次方

1. import java.util.Scanner;
2. public class Main {
3. public static void main(String[] args) {
4.        Scanner sc=new Scanner(System.in);
5. int N=sc.nextInt();
6.         System.out.println(Integer.toString(N,2));//打印几进制
7. int count=0;
8. while(N!=0){
9.     N=(N-1)&N;
10.     count++;
11. }
12. if(count==1) System.out.println("yes");
13. else System.out.println("no");
14. 
15. //System.out.println(count);
16. 
17. 
18.     }
19. 
20. 
21. }

将整数的奇偶位互换

1. import java.util.Scanner;
2. 
3. public class Main {
4. 
5. 
6. public static void main(String[] args) {
7. 
8. //int a = 0b010000000_00000000_00000000_00000000; 测试边界是否满足
9.         Scanner sc=new Scanner(System.in);
10. int a = sc.nextInt();
11. 
12.         System.out.println("交换前整数:"+a);
13. 
14.         System.out.println("交换前整数二进制:"+Integer.toString(a,2));
15. 
16. int b = m(a);
17. 
18.         System.out.println("交换后整数:"+b);
19. 
20.         System.out.println("交换后整数二进制:"+Integer.toString(b,2));
21. 
22. 
23.     }
24. 
25. private static int m(int i) {
26. 
27. int ji = i & 0x55555555; //和0101 0101 0101 .。。。。 做与运算保留奇数位 相当于取出
28. 
29. 
30. int ou = i & 0xaaaaaaaa; //和1010 1010 1010 .。。。。 做与运算保留偶数位 相当于取出
31. 
32. return (ou>>1)^(ji<<1);
33. 
34.     }
35. 
36. }

二进制表示浮点实数

1. public class Main {
2. 
3.     public static void main(String[] args) {
4. 
5. double num = 0.625;
6. 
7.         StringBuilder sb = new StringBuilder("0.");
8. 
9. while(num>0){
10. 
11. // 乘2：挪整
12. 
13. double r = num * 2;
14. 
15. // 判断整数部分
16. 
17. if (r>=1) {
18. 
19.                 sb.append("1");
20. 
21. // 消除整数部分
22. 
23. num = r - 1;
24. 
25. 
26.             }else {
27. 
28.                 sb.append("0");
29. 
30. num = r;
31. 
32.             }
33. 
34. if (sb.length()>34) { // 这里的34包括“0.”长度
35. 
36.                 System.out.println("ERROR");
37. 
38. return ;
39. 
40.             }
41. 
42.         }
43. 
44.         System.out.println(sb.toString()); // 结果为0.101
45. 
46.     }
47. 
48. }

出现一次和出现k次

1. public class find1 {
2.  public static void main(String[] args) {
3.    // TODO Auto-generated method stub
4. 
5.    int[] arr={5,5,5,2,2,2,4,6,6,6};
6.    int len = arr.length;
7.    int [][] kRadix = new int[len+1][3];
8.    int k=0;
9. 
10.     //将2进制数转换成3进制数，存在2维数组中
11.     for(int i=0;i<len;i++)
12.     {
13.       for(int j=0;j<3;j++)
14.       {
15.         kRadix[i][j]=arr[i]%3;
16.         arr[i]/=3;
17.       }
18.     }
19. 
20.     //输出高低位反着的3进制数
21.     for(int i=0;i<len;i++)
22.     {
23.       for(int j=0;j<3;j++)
24.       {
25.         System.out.print(kRadix[i][j]);
26.       }
27.       System.out.println();
28.     }
29. 
30.     //进行不进位的加法
31.     for(int j=0;j<3;j++)
32.       {
33.         for(int i=0;i<len;i++)
34.         {
35.           kRadix[len][j]+=kRadix[i][j];
36.           kRadix[len][j]%=3;
37.         }
38.       }
39. 
40.     //将个数为1的数存放在最后一行二维数组中
41.       for(int j=0;j<3;j++)
42.         {
43.           System.out.print(kRadix[len][j]);
44.       k+=kRadix[len][j]*(int)(Math.pow(3,j));//将3进制数转换为10进制数
45.         }
46.        System.out.println();
47.           System.out.println("个数为一的数为：");
48.         System.out.print(k);
49.   }
50. }

二进制以及位运算