java编程基础（二）位运算符

红太狼 2023-02-25 08:58 23阅读 0赞

### 文章目录 ###

*  位运算符
 *  位运算
 *   *  1. 位与 &
     *  2. 位或 |
     *  3. 异或 ^
     *  4. 求反 ~
 *  移位运算
 *   *  带符号右移位
     *  不带符号右移位
 *  面试题
 *  练一练
 *   *  1. 获得任意\`int\`整数的二进制码
     *   *  代码
     *  2. \`int\`整数的32位，分拆成4个\`byte\`值
     *   *  代码
     *  3. 四个\`byte\`值 合并成一个 \`int\` 整数
     *   *  合并第一个字节
         *  合并第二个字节
         *  代码
 *  代码仓库

# 位运算符 #

针对二进制运算，java提供了位运算符：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>位与</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>位或</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>求反</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移位</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>带符号右移位</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&gt;</td> 
   <td>不带符号右移位</td> 
  </tr> 
 </tbody> 
</table>

# 位运算 #

## 1. 位与 & ##

两个整数值的32位，每一位和每一位求与。

两位都是1与得的结果是1；只要有0结果就是0。

00000000 00000000 00000000 01101001
    00000000 00000000 00000000 00100011 &
    ----------------------------------------
    00000000 00000000 00000000 00100001

## 2. 位或 | ##

只要有1结果就是1；两位都是0结果是0。

00000000 00000000 00000000 01101001
    00000000 00000000 00000000 00100011 |
    ----------------------------------------
    00000000 00000000 00000000 01101011

## 3. 异或 ^ ##

异或运算是“找不同”

不同是1；相同是0。

00000000 00000000 00000000 01101001
    00000000 00000000 00000000 00100011 ^
    ----------------------------------------
    00000000 00000000 00000000 01001010

异或还有个特点，就是**对同一个值异或两次会得到原值**。  
试着用上面异或的结果再对第二个值求一次异或，这样可以还原成第一个值。

## 4. 求反 ~ ##

1变0；0变1。

求反运算只有一个运算项

00000000 00000000 00000000 01101001 ~
    ----------------------------------------
    11111111 11111111 11111111 10010110

# 移位运算 #

## 带符号右移位 ##

所有位整体向右移动，右侧移出部分截断。

**侧符号位是0，在左侧补0。**

![移位][20200712103118611.gif_pic_center]

**符号位是1，在左侧补1。**

![移位][20200712154307901.gif_pic_center]

## 不带符号右移位 ##

不管符号位是0还是1，左侧都补0。

1000000000000000000000011101011 >>> 2
    
    结果：
    0010000000000000000000000111010

# 面试题 #

乘2和除2，除了用 `*` `/` 运算符，还可以如何运算？

# 练一练 #

## 1. 获得任意`int`整数的二进制码 ##

![移位][2020071217190856.gif_pic_center]

### 代码 ###

package demo2;
    
    import java.util.Scanner;
    
    public class Test1 { 
        public static void main(String[] args) { 
            while (true) { 
                System.out.print("输入整数的二进制码：");
                int a = new Scanner(System.in).nextInt();
    
                String code = binaryCode(a);
                System.out.println("二进制码： " + code);
            }
        }
    
        static String binaryCode(int a) { 
            int p = 1 << 31; //最左侧位是1
    
            String s = "";
            for (int i = 0; i < 32; i++) { 
                int r = a & (p >>> i);
    
                if (r == 0) { 
                    s += "0";
                } else { 
                    s += "1";
                }
            }
    
            return s;
        }
    }

## 2. `int`整数的32位，分拆成4个`byte`值 ##

![拆分][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODMwNTQ0MA_size_16_color_FFFFFF_t_70_pic_center]

获取左侧第一个字节可以这样做：

1.  **把左侧第一个字节移动到最右侧**

![拆分][20200712194043734.png_pic_center]

1.  **强转成 `byte`，这时会截断 `int`，只保留右侧末尾的一个字节**

![在这里插入图片描述][20200712194525437.png_pic_center]  
以此类推，把每个字节都移动到最右侧再强转成 `byte`，就可以完成分拆。

### 代码 ###

package demo2;
    
    import java.util.Scanner;
    
    public class Test2 { 
        public static void main(String[] args) { 
            while (true) { 
                System.out.print("输入整数：");
                int n = new Scanner(System.in).nextInt();
                // int 整数转成四个 byte 值
                byte[] a = split(n);
                for (byte b : a) { 
                    System.out.println(b);
                }
            }
    
        }
    
        static byte[] split(int n) { 
            byte[] a = new byte[4];
            for (int i = 0; i < a.length; i++) { 
                // n循环右移四次，分别移动 24,16,8,0 位
                a[i] = (byte) (n >> (8 * (3 - i)));
            }
    
            return a;
        }
    }

## 3. 四个`byte`值 合并成一个 `int` 整数 ##

![合并][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODMwNTQ0MA_size_16_color_FFFFFF_t_70_pic_center 1]

### 合并第一个字节 ###

首先准备一个整数0：

![合并][20200712200923430.png_pic_center]  
我们打算把这个字节放到**左侧**第一个字节：

![合并][20200712201142979.png_pic_center]

`byte` 运算时会被自动转成 `int`，变成32位，**如果符号位是1，左侧会补1**：

![合并][20200712201553879.png_pic_center]

我们把这个字节移动到最左侧：

![合并][20200712202006608.png_pic_center]

两个值求位或：

![合并][20200712203637343.png_pic_center]

### 合并第二个字节 ###

从上一步的结果开始：

![合并][20200712204059861.png_pic_center]  
这个个字节会先变成 `int`，**如果符号位是1，左侧会补1**：

![合并][20200712204332474.png_pic_center]

把它左移到第二个字节位置：

![合并][20200712204641675.png_pic_center]

**注意看，左侧8位现在都是1**

只留下我们需要的8位，把其他24位都抹成0，像下面这样求个位与运算（两位都是1结果是1，有0就是0）

![合并][20200712232100932.png_pic_center]

把其他位抹成0了，接下来再求位或，这样就完成了第二个字节的合并：

![合并][20200712233231328.png_pic_center]  
以此类推，可以继续完成后面两个字节的合并过程。

### 代码 ###

package demo2;
    
    import java.util.Scanner;
    
    public class Test3 { 
        public static void main(String[] args) { 
            while (true) { 
                byte[] a = new byte[4];
                System.out.println("输入四个byte值：");
                for (int i = 0; i < a.length; i++) { 
                    a[i] = new Scanner(System.in).nextByte();
                }
    
                int r = toInt(a);
                System.out.println("合并结果： "+r);
            }
        }
    
        static int toInt(byte[] a) { 
            int r = 0;
    
            for (int i = 0; i < a.length; i++) { 
                // 先向左移动 24,16,8,0 位
                int tmp = a[i] << (8 * (3 - i));
                // 再把不需要的位抹成0
                tmp = tmp & (0b11111111 << (8 * (3 - i)));
                // 再求位或
                r |= tmp;
            }
    
            return r;
        }
    }

# 代码仓库 #

[https://gitee.com/benwang6/java-review][https_gitee.com_benwang6_java-review]

[20200712103118611.gif_pic_center]: /images/20230209/6de9a0d7811d4389815fd4cd2e9fc1d6.png
[20200712154307901.gif_pic_center]: /images/20230209/78219260b0f244638ced0b440b51c71d.png
[2020071217190856.gif_pic_center]: /images/20230209/3054b47ac5f948b591fe419bf3d0dabc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODMwNTQ0MA_size_16_color_FFFFFF_t_70_pic_center]: /images/20230209/49e30b71f3b04744b574aa28471ccf34.png
[20200712194043734.png_pic_center]: /images/20230209/474a23f28fd3430ba8a43951916a2118.png
[20200712194525437.png_pic_center]: /images/20230209/630b34802e2b40e8ac7aa460f7a2d67e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODMwNTQ0MA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230209/e305f4bccb0b4450932c4a8fef82fa03.png
[20200712200923430.png_pic_center]: /images/20230209/65c91899a6dc430d87a1bff1cfd7caad.png
[20200712201142979.png_pic_center]: /images/20230209/51ab23dfedf144ac90366ac41317b2d9.png
[20200712201553879.png_pic_center]: /images/20230209/34911e5b6e7e4e65a76a7bec1f2f54b2.png
[20200712202006608.png_pic_center]: /images/20230209/adc43095c706467ba2c79295141914f7.png
[20200712203637343.png_pic_center]: /images/20230209/fef16ca96cbc48bc851dae74e80f193e.png
[20200712204059861.png_pic_center]: /images/20230209/60275ec8472c4f208a57b2e74c92bd2f.png
[20200712204332474.png_pic_center]: /images/20230209/de3ae3d93f3d48468f8cbc0482f232dd.png
[20200712204641675.png_pic_center]: /images/20230209/5d05a197d2824c9aa22d0d78657a3ea4.png
[20200712232100932.png_pic_center]: /images/20230209/37ae6a24a6ea49b28dd9e9f3ed84d6ac.png
[20200712233231328.png_pic_center]: /images/20230209/49369965e6fa48febcd2d3b030f4bf80.png
[https_gitee.com_benwang6_java-review]: https://gitee.com/benwang6/java-review