180天Java从小白到就业-Day03-03Java位运算符、赋值运算符、数据交换的三种方式

1. 位运算符

Q：为什么要学习位运算

A：由于其运算效率更高，在JDK源码（例如ArrayList、HashMap）中大量使用位运算，想要看懂JDK源码必须懂位预算，但是在公司开发业务系统时位运算使用并不多。

Q：学习位运算需要提前储备哪些知识点

A：由于位运算底层运算是基于二进制，因此需要掌握计算机进制，包括二进制、十进制以及它们之间的相互转换，由于计算机数据底层都是基于补码进行运算，查看结果需要转换为原码，因此还需要了解原码、反码、补码以及它们之间的相互转换。

1.1 位运算符介绍

Java提供了7个位运算符

位运算符	说明	计算规则
&	按位与	按照二进制位进行与运算：同1为1，有0为0
|	按位或	按照二进制位进行或运算：有1为1，同0为0
^	按位异或	按照二进制位进行异或运算：相同为0，不同为1
~	按位取反	按照二进制位取反：1为0，0为1
<<	左移运算符	用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方。
>>	右移运算符	用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。 右移n位在一定范围内就是除以2的n次方。
>>>	无符号右移运算符	用于将数据的二进制位向右移动，左边填充0

按位运算符的按位与（&）、按位或（|）、按位异或（^）和逻辑运算符的逻辑与（&）、逻辑或（|）、逻辑异或（^）使用的符号相同。

Q：如何确定符号是位运算符还是逻辑运算符

A：看表达式的操作数即可，如果表达式的操作数是整数那么就是位运算符，如果表达式的操作数是boolean类型的数据就是逻辑运算符

1.2 按位与运算符

1.2.1 按位与运算符操作正整数

1.2.1.1 按位与运算符操作正整数之5 & 2

1. 新建包net.ittimeline.java.core.foundational.operator.bit

2. 新建源文件BitAndOperatorPositiveNumberExample1.java

3. 编辑源文件BitAndOperatorPositiveNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位与运算符操作正整数之 5 & 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 11:52
 * @since Java21
 */
public class BitAndOperatorPositiveNumberExample1 {
    public static void main(String[] args) {
        /*
            1.先计算5和2的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101
            2的补码：0000 0000 0000 0000 0000 0000 0000 0010
            2.计算5 & 2
            按位与计算规则是按照二进制位进行与运算：同1为1，有0为0
            0000 0000 0000 0000 0000 0000 0000 0101
            &
            0000 0000 0000 0000 0000 0000 0000 0010
            =
            0000 0000 0000 0000 0000 0000 0000 0000
            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码0000 0000 0000 0000 0000 0000 0000 0000的原码是0000 0000 0000 0000 0000 0000 0000 0000
            4.将原码转换为十进制
            打印输出结果是十进制
            0000 0000 0000 0000 0000 0000 0000 0000转换为十进制结果是0
            5. 最终结果就是5 & 2 = 0

         */
        System.out.println("5 & 2 = " + (5 & 2));
    }
}

4. 运行BitAndOperatorPositiveNumberExample1

程序运行结果

1.2.1.2 按位与运算符操作正整数之5 & 3

1. 新建源文件BitAndOperatorPositiveNumberExample2.java

2. 编辑源文件BitAndOperatorPositiveNumberExample2.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位与运算符操作正整数之 5 & 3
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 12:09
     * @since Java21
     */
    public class BitAndOperatorPositiveNumberExample2 {
        public static void main(String[] args) {
            /*
                1.先计算5和3的补码
                计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
                5的补码：0000 0000 0000 0000 0000 0000 0000 0101
                3的补码：0000 0000 0000 0000 0000 0000 0000 0011
                2.计算5 & 3
                按位与计算规则是按照二进制位进行与运算：同1为1，有0为0
                0000 0000 0000 0000 0000 0000 0000 0101
                &
                0000 0000 0000 0000 0000 0000 0000 0011
                =
                0000 0000 0000 0000 0000 0000 0000 0001
                3.将补码换算成原码
                查看运算结果看原码,正数的原码、反码、补码都一样
                补码0000 0000 0000 0000 0000 0000 0000 0001的原码是0000 0000 0000 0000 0000 0000 0000 0001
                4.将原码转换为十进制
                打印输出结果是十进制
                0000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是1
                5. 最终结果就是5 & 3 = 1
    
             */
            System.out.println("5 & 3 = " + (5 & 3));
        }
    }
    

3. 运行BitAndOperatorPositiveNumberExample2

程序运行结果

1.2.2 按位与运算符操作负整数

1.2.2.1 按位与运算符操作负整数之 -5 & -3

1. 新建源文件BitAndOperatorNegativeNumberExample1.java

2. 编辑源文件BitAndOperatorNegativeNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位与运算符操作负整数之 -5 & -3
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 12:15
 * @since Java21
 */
public class BitAndOperatorNegativeNumberExample1 {
    public static void main(String[] args) {
      /*
            1.先计算-5和-3的补码
            计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
            ①求5和3的原码
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
            3的原码：0000 0000 0000 0000 0000 0000 0000 0011
            ②求-5和-3的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
            -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
            -3的原码：1000 0000 0000 0000 0000 0000 0000 0011
            ③求-5和-3的反码（原码求反码：最高位不变，其他位取反）
            -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
            -3的反码：1111 1111 1111 1111 1111 1111 1111 1100
            ④求-5和-3的补码（补码=反码+1）
            -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
            -3的补码：1111 1111 1111 1111 1111 1111 1111 1101
            2.计算-5 & -3
            按位与计算规则是按照二进制位进行与运算：同1为1，有0为0
            1111 1111 1111 1111 1111 1111 1111 1011
            &
            1111 1111 1111 1111 1111 1111 1111 1101
            =
            1111 1111 1111 1111 1111 1111 1111 1001
            3.将补码换算成原码（根据补码求原码）
            ①根据补码求反码：补码-1=反码
            1111 1111 1111 1111 1111 1111 1111 1001-1=1111 1111 1111 1111 1111 1111 1111 1000
            ②根据反码求原码：最高位不变，其他位取反
            1111 1111 1111 1111 1111 1111 1111 1000转换为原码是1000 0000 0000 0000 0000 0000 0000 0111
            4.将原码转换为十进制（ 打印输出结果是十进制）
            1000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是-7
            5. 最终结果就是-5 & -3 = -7
         */
        System.out.println("-5 & -3 = " + (-5 & -3));
    }
}

3. 运行BitAndOperatorNegativeNumberExample1

程序运行结果

1.2.2.2 按位与运算符操作负整数之 -5 & -10

1. 新建源文件BitAndOperatorNegativeNumberExample2.java

2. 编辑源文件BitAndOperatorNegativeNumberExample2.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位与运算符操作负整数之 -5 & -10
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 12:29
     * @since Java21
     */
    public class BitAndOperatorNegativeNumberExample2 {
        public static void main(String[] args) {
            /*
                1.先计算-5和-10的补码
                计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
                ①求5和10的原码
                5的原码：0000 0000 0000 0000 0000 0000 0000 0101
               10的原码：0000 0000 0000 0000 0000 0000 0000 1010
                ②求-5和-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
                -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
               -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
                ③求-5和-10的反码（原码求反码：最高位不变，其他位取反）
                -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
               -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
                ④求-5和-10的补码（补码=反码+1）
                -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
               -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
                2.计算-5 & -10
                按位与计算规则是按照二进制位进行与运算：同1为1，有0为0
                1111 1111 1111 1111 1111 1111 1111 1011
                &
                1111 1111 1111 1111 1111 1111 1111 0110
                =
                1111 1111 1111 1111 1111 1111 1111 0010
                3.将补码换算成原码（根据补码求原码）
                ①根据补码求反码：补码-1=反码
                1111 1111 1111 1111 1111 1111 1111 0010-1=1111 1111 1111 1111 1111 1111 1111 0001
                ②根据反码求原码：最高位不变，其他位取反
                1111 1111 1111 1111 1111 1111 1111 0001转换为原码是1000 0000 0000 0000 0000 0000 0000 1110
                4.将原码转换为十进制（ 打印输出结果是十进制）
                1000 0000 0000 0000 0000 0000 0000 1110转换为十进制结果是-14
                5. 最终结果就是-5 & -10 = -14
             */
            System.out.println("-5 & -10 = " + (-5 & -10));
        }
    }
    

3. 运行BitAndOperatorNegativeNumberExample2

程序运行结果

1.2.2.3 按位与运算符操作负整数之5 & -10

1. 新建源文件BitAndOperatorNegativeNumberExample3.java

2. 编辑源文件BitAndOperatorNegativeNumberExample3.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位与运算符操作负整数之5 & -10
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 12:42
 * @since Java21
 */
public class BitAndOperatorNegativeNumberExample3 {
    public static void main(String[] args) {
        /*
            1.先计算5和-10的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求5和10的原码
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
           10的原码：0000 0000 0000 0000 0000 0000 0000 1010
            ②求5和-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
          -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
            ③求5和-10的反码（原码求反码：最高位不变，其他位取反）
            5的反码：0000 0000 0000 0000 0000 0000 0000 0101
          -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
            ④求-5和-3的补码（补码=反码+1）
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101
          -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
            2.计算5 & -10
            按位与计算规则是按照二进制位进行与运算：同1为1，有0为0
            0000 0000 0000 0000 0000 0000 0000 0101
            &
            1111 1111 1111 1111 1111 1111 1111 0110
            =
            0000 0000 0000 0000 0000 0000 0000 0100
            3.将补码换算成原码
            补码0000 0000 0000 0000 0000 0000 0000 0100转换成原码是0000 0000 0000 0000 0000 0000 0000 0100
            4.将原码转换为十进制（ 打印输出结果是十进制）
            0000 0000 0000 0000 0000 0000 0000 0100转换为十进制结果是4
            5. 最终结果就是5 & -10 = 4
         */
        System.out.println("5 & -10 = " + (5 & -10));
    }
}

3. 运行BitAndOperatorNegativeNumberExample3

程序运行结果

1.3 按位或运算符

1.3.1 按位或运算符操作正整数

1.3.1.1 按位或运算符操作正整数之 5 | 2

1. 新建源文件BitOrOperatorPositiveNumberExample1.java

2. 编辑源文件BitOrOperatorPositiveNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位或运算符操作正整数之 5 | 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 12:52
 * @since Java21
 */
public class BitOrOperatorPositiveNumberExample1 {
    public static void main(String[] args) {
       /*
            1.先计算5和2的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101
            2的补码：0000 0000 0000 0000 0000 0000 0000 0010
            2.计算5 | 2
            按位或计算规则是按照二进制位进行或运算：有1为1，同0为0
            0000 0000 0000 0000 0000 0000 0000 0101
            |
            0000 0000 0000 0000 0000 0000 0000 0010
            =
            0000 0000 0000 0000 0000 0000 0000 0111
            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码0000 0000 0000 0000 0000 0000 0000 0111的原码是0000 0000 0000 0000 0000 0000 0000 0111
            4.将原码转换为十进制
            打印输出结果是十进制
            0000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是7
            5. 最终结果就是5 | 2 = 7

         */
        System.out.println("5 | 2 = " + (5 | 2));
    }
}

3. 运行BitOrOperatorPositiveNumberExample1

程序运行结果

1.3.1.2 按位或运算符操作正整数之 5 | 3

1. 新建源文件BitOrOperatorPositiveNumberExample2.java

2. 编辑源文件BitOrOperatorPositiveNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位或运算符操作正整数之 5 | 3
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 13:27
 * @since Java21
 */
public class BitOrOperatorPositiveNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算5和3的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101
            3的补码：0000 0000 0000 0000 0000 0000 0000 0011
            2.计算5 | 3
            按位或计算规则是按照二进制位进行或运算：有1为1，同0为0
            0000 0000 0000 0000 0000 0000 0000 0101
            |
            0000 0000 0000 0000 0000 0000 0000 0011
            =
            0000 0000 0000 0000 0000 0000 0000 0111
            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码0000 0000 0000 0000 0000 0000 0000 0111的原码是0000 0000 0000 0000 0000 0000 0000 0111
            4.将原码转换为十进制
            打印输出结果是十进制
            0000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是7
            5. 最终结果就是5 | 3 = 7

         */
        System.out.println("5 | 3 = " + (5 | 3));
    }
}

3. 运行BitOrOperatorPositiveNumberExample2

程序运行结果

1.3.2 按位或运算符操作负整数

1.3.2.1 按位或运算符操作负整数之 -5 |-3

1. 新建源文件BitOrOperatorNegativeNumberExample1.java

2. 编辑源文件BitOrOperatorNegativeNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位或运算符操作负整数之 -5 |-3
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 13:34
 * @since Java21
 */
public class BitOrOperatorNegativeNumberExample1 {
    public static void main(String[] args) {
        /*
            1.先计算-5和-3的补码
            计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
            ①求5和3的原码
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
            3的原码：0000 0000 0000 0000 0000 0000 0000 0011
            ②求-5和-3的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
            -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
            -3的原码：1000 0000 0000 0000 0000 0000 0000 0011
            ③求-5和-3的反码（原码求反码：最高位不变，其他位取反）
            -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
            -3的反码：1111 1111 1111 1111 1111 1111 1111 1100
            ④求-5和-3的补码（补码=反码+1）
            -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
            -3的补码：1111 1111 1111 1111 1111 1111 1111 1101
            2.计算-5 | -3
            按位或计算规则是按照二进制位进行或运算：有1为1，同0为0
            1111 1111 1111 1111 1111 1111 1111 1011
            |
            1111 1111 1111 1111 1111 1111 1111 1101
            =
            1111 1111 1111 1111 1111 1111 1111 1111
            3.将补码换算成原码（根据补码求原码）
            ①根据补码求反码：补码-1=反码
            1111 1111 1111 1111 1111 1111 1111 1111-1=1111 1111 1111 1111 1111 1111 1111 1110
            ②根据反码求原码：最高位不变，其他位取反
            1111 1111 1111 1111 1111 1111 1111 1110转换为原码是1000 0000 0000 0000 0000 0000 0000 0001
            4.将原码转换为十进制（ 打印输出结果是十进制）
            1000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是-1
            5. 最终结果就是-5 | -3 = -1
         */
        System.out.println("-5 | -3 = " + (-5 | -3));
    }
}

3. 运行BitOrOperatorNegativeNumberExample1

程序运行结果

1.3.2.2 按位或运算符操作负整数之 -5 |-10

1. 新建源文件BitOrOperatorNegativeNumberExample2.java

2. 编辑源文件BitOrOperatorNegativeNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位或运算符操作负整数之 -5 |-10
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 13:39
 * @since Java21
 */
public class BitOrOperatorNegativeNumberExample2 {
    public static void main(String[] args) {
        /*
            1.先计算-5和-10的补码
            计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
            ①求5和10的原码
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
           10的原码：0000 0000 0000 0000 0000 0000 0000 1010
            ②求-5和-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
            -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
           -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
            ③求-5和-10的反码（原码求反码：最高位不变，其他位取反）
            -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
           -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
            ④求-5和-10的补码（补码=反码+1）
            -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
           -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
            2.计算-5 | -10
            按位或计算规则是按照二进制位进行或运算：有1为1，同0为0
            1111 1111 1111 1111 1111 1111 1111 1011
            |
            1111 1111 1111 1111 1111 1111 1111 0110
            =
            1111 1111 1111 1111 1111 1111 1111 1111
            3.将补码换算成原码（根据补码求原码）
            ①根据补码求反码：补码-1=反码
            1111 1111 1111 1111 1111 1111 1111 1111-1=1111 1111 1111 1111 1111 1111 1111 1110
            ②根据反码求原码：最高位不变，其他位取反
            1111 1111 1111 1111 1111 1111 1111 1110转换为原码是1000 0000 0000 0000 0000 0000 0000 0001
            4.将原码转换为十进制（ 打印输出结果是十进制）
            1000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是-1
            5. 最终结果就是-5 | -10 = -1
         */
        System.out.println("-5 | -10 = " + (-5 | -10));
    }
}

3. 运行BitOrOperatorNegativeNumberExample2

程序运行结果

1.3.2.3 按位或运算操作负整数之 5 |-10

1. 新建源文件BitOrOperatorNegativeNumberExample3.java

2. 编辑源文件BitOrOperatorNegativeNumberExample3.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位或运算符操作负整数之 5 |-10
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 13:52
     * @since Java21
     */
    public class BitOrOperatorNegativeNumberExample3 {
        public static void main(String[] args) {
            /*
                1.先计算5和-10的补码
                计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
                ①求5和10的原码
                5的原码：0000 0000 0000 0000 0000 0000 0000 0101
               10的原码：0000 0000 0000 0000 0000 0000 0000 1010
                ②求5和-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
                5的原码：0000 0000 0000 0000 0000 0000 0000 0101
              -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
                ③求5和-10的反码（原码求反码：最高位不变，其他位取反）
                5的反码：0000 0000 0000 0000 0000 0000 0000 0101
              -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
                ④求-5和-3的补码（补码=反码+1）
                5的补码：0000 0000 0000 0000 0000 0000 0000 0101
              -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
                2.计算5 | -10
                按位或计算规则是按照二进制位进行或运算：有1为1，同0为0
                0000 0000 0000 0000 0000 0000 0000 0101
                |
                1111 1111 1111 1111 1111 1111 1111 0110
                =
                1111 1111 1111 1111 1111 1111 1111 0111
                3.将补码换算成原码
                ①根据补码求反码：反码=补码-1
                1111 1111 1111 1111 1111 1111 1111 0111-1=1111 1111 1111 1111 1111 1111 1111 0110
                ②根据反码求原码：最高位不变，其他位取反
                反码1111 1111 1111 1111 1111 1111 1111 0110转换成原码是1000 0000 0000 0000 0000 0000 0000 1001
                4.将原码转换为十进制（ 打印输出结果是十进制）
                1000 0000 0000 0000 0000 0000 0000 1001转换为十进制结果是-9
                5. 最终结果就是5 | -10 = -9
             */
            System.out.println("5 | -10 = " + (5 | -10));
        }
    }
    

3. 运行BitOrOperatorNegativeNumberExample3

程序运行结果

1.4 按位异或运算符

1.4.1 按位异或运算符操作正整数

1.4.1.1 按位异或运算符操作正整数之 5 ^ 2

1. 新建源文件BitXorOperatorPositiveNumberExample1.java

2. 编辑源文件BitXorOperatorPositiveNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位异或运算符操作正整数之 5 ^ 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 14:08
 * @since Java21
 */
public class BitXorOperatorPositiveNumberExample1 {
    public static void main(String[] args) {
        /*
            1.先计算5和2的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101
            2的补码：0000 0000 0000 0000 0000 0000 0000 0010
            2.计算5 ^ 2
            按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为1
            0000 0000 0000 0000 0000 0000 0000 0101
            ^
            0000 0000 0000 0000 0000 0000 0000 0010
            =
            0000 0000 0000 0000 0000 0000 0000 0111
            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码0000 0000 0000 0000 0000 0000 0000 0111的原码是0000 0000 0000 0000 0000 0000 0000 0111
            4.将原码转换为十进制
            打印输出结果是十进制
            0000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是7
            5. 最终结果就是5 ^ 2 = 7

         */
        System.out.println("5 ^ 2 = " + (5 ^ 2));
    }
}

3. 运行BitXorOperatorPositiveNumberExample1

程序运行结果

1.4.1.2 按位异或运算符操作正整数之 5 ^ 3

1. 新建源文件BitXorOperatorPositiveNumberExample2.java

2. 编辑源文件BitXorOperatorPositiveNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位异或运算符操作正整数之 5 ^ 3
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 14:12
 * @since Java21
 */
public class BitXorOperatorPositiveNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算5和3的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101
            3的补码：0000 0000 0000 0000 0000 0000 0000 0011
            2.计算5 ^ 3
            按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为1
            0000 0000 0000 0000 0000 0000 0000 0101
            ^
            0000 0000 0000 0000 0000 0000 0000 0011
            =
            0000 0000 0000 0000 0000 0000 0000 0110
            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码0000 0000 0000 0000 0000 0000 0000 0110的原码是0000 0000 0000 0000 0000 0000 0000 0110
            4.将原码转换为十进制
            打印输出结果是十进制
            0000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是6
            5. 最终结果就是5 ^ 3 = 6

         */
        System.out.println("5 ^ 3 = " + (5 ^ 3));
    }
}

3. 运行BitXorOperatorPositiveNumberExample2

程序运行结果

1.4.2 按位异或运算符操作负整数

1.4.2.1 按位异或运算符操作负整数之 -5 ^ -3

1. 新建源文件BitXorOperatorNegativeNumberExample1.java

2. 编辑源文件BitXorOperatorNegativeNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位异或运算符操作负整数之 -5 ^ -3
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 14:15
 * @since Java21
 */
public class BitXorOperatorNegativeNumberExample1 {
    public static void main(String[] args) {
          /*
            1.先计算-5和-3的补码
            计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
            ①求5和3的原码
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
            3的原码：0000 0000 0000 0000 0000 0000 0000 0011
            ②求-5和-3的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
            -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
            -3的原码：1000 0000 0000 0000 0000 0000 0000 0011
            ③求-5和-3的反码（原码求反码：最高位不变，其他位取反）
            -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
            -3的反码：1111 1111 1111 1111 1111 1111 1111 1100
            ④求-5和-3的补码（补码=反码+1）
            -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
            -3的补码：1111 1111 1111 1111 1111 1111 1111 1101
            2.计算-5 ^ -3
            按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为1
            1111 1111 1111 1111 1111 1111 1111 1011
            ^
            1111 1111 1111 1111 1111 1111 1111 1101
            =
            0000 0000 0000 0000 0000 0000 0000 0110
            3.将补码换算成原码（根据补码求原码）
            补码0000 0000 0000 0000 0000 0000 0000 0110的原码是0000 0000 0000 0000 0000 0000 0000 0110
            4.将原码转换为十进制（ 打印输出结果是十进制）
            0000 0000 0000 0000 0000 0000 0000 0110转换为十进制结果是6
            5. 最终结果就是-5 ^ -3 = 6
         */
        System.out.println("-5 ^ -3 = " + (-5 ^ -3));
    }
}

3. 运行BitXorOperatorNegativeNumberExample1

程序运行结果

1.4.2.2 按位异或运算符操作负整数之 -5 ^ -10

1. 新建源文件BitXorOperatorNegativeNumberExample2.java

2. 编辑源文件BitXorOperatorNegativeNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位异或运算符操作负整数之 -5 ^ -10
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 14:22
 * @since Java21
 */
public class BitXorOperatorNegativeNumberExample2 {
    public static void main(String[] args) {
        /*
            1.先计算-5和-10的补码
            计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
            ①求5和10的原码
            5的原码：0000 0000 0000 0000 0000 0000 0000 0101
           10的原码：0000 0000 0000 0000 0000 0000 0000 1010
            ②求-5和-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
            -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
           -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
            ③求-5和-10的反码（原码求反码：最高位不变，其他位取反）
            -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
           -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
            ④求-5和-10的补码（补码=反码+1）
            -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
           -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
            2.计算-5 ^ -10
            按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为1
            1111 1111 1111 1111 1111 1111 1111 1011
            ^
            1111 1111 1111 1111 1111 1111 1111 0110
            =
            0000 0000 0000 0000 0000 0000 0000 1101
            3.将补码换算成原码（根据补码求原码）
            补码0000 0000 0000 0000 0000 0000 0000 1101转换为原码是0000 0000 0000 0000 0000 0000 0000 1101
            4.将原码转换为十进制（ 打印输出结果是十进制）
            0000 0000 0000 0000 0000 0000 0000 1101转换为十进制结果是13
            5. 最终结果就是-5 ^ -10 = 13
         */
        System.out.println("-5 ^ -10 = " + (-5 ^ -10));
    }
}

3. 运行BitXorOperatorNegativeNumberExample2

程序运行结果

1.4.2.3 按位异或运算符操作负整数之 5 ^ -10

1. 新建源文件BitXorOperatorNegativeNumberExample3.java

2. 编辑源文件BitXorOperatorNegativeNumberExample3.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位异或运算符操作负整数之 5 ^ -10
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 14:28
     * @since Java21
     */
    public class BitXorOperatorNegativeNumberExample3 {
        public static void main(String[] args) {
            /*
                1.先计算5和-10的补码
                计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
                ①求5和10的原码
                5的原码：0000 0000 0000 0000 0000 0000 0000 0101
               10的原码：0000 0000 0000 0000 0000 0000 0000 1010
                ②求5和-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
                5的原码：0000 0000 0000 0000 0000 0000 0000 0101
              -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
                ③求5和-10的反码（原码求反码：最高位不变，其他位取反）
                5的反码：0000 0000 0000 0000 0000 0000 0000 0101
              -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
                ④求-5和-3的补码（补码=反码+1）
                5的补码：0000 0000 0000 0000 0000 0000 0000 0101
              -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
                2.计算5 ^ -10
                按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为1
                0000 0000 0000 0000 0000 0000 0000 0101
                ^
                1111 1111 1111 1111 1111 1111 1111 0110
                =
                1111 1111 1111 1111 1111 1111 1111 0011
                3.将补码换算成原码
                ①根据补码求反码：反码=补码-1
                1111 1111 1111 1111 1111 1111 1111 0011-1=1111 1111 1111 1111 1111 1111 1111 0010
                ②根据反码求原码：最高位不变，其他位取反
                反码1111 1111 1111 1111 1111 1111 1111 0010转换成原码是1000 0000 0000 0000 0000 0000 0000 1101
                4.将原码转换为十进制（ 打印输出结果是十进制）
                1000 0000 0000 0000 0000 0000 0000 1101转换为十进制结果是-13
                5. 最终结果就是5 ^ -10 = -13
             */
            System.out.println("5 ^ -10 = " + (5 ^ -10));
        }
    }

3. 运行BitXorOperatorNegativeNumberExample3

程序运行结果

1.5 按位取反运算符

1.5.1 按位取反运算符操作正整数

1.5.1.1 按位取反运算符操作正整数之~5

1. 新建源文件BitNotOperatorPositiveNumberExample1.java

2. 编辑源文件BitNotOperatorPositiveNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位取反运算符操作正整数之~5
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 14:45
 * @since Java21
 */
public class BitNotOperatorPositiveNumberExample1 {
    public static void main(String[] args) {
         /*
            1.先计算5的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 0101

            2.计算~5
            按位与计算规则是按照二进制位取反：1为0，0为1
            0000 0000 0000 0000 0000 0000 0000 0101
            ~
            =
            1111 1111 1111 1111 1111 1111 1111 1010
            3.将补码换算成原码
            查看运算结果看原码,负数的原码是补码减1取反
            ①根据补码求反码：反码=补码减1
            1111 1111 1111 1111 1111 1111 1111 1010-1=1111 1111 1111 1111 1111 1111 1111 1001
            ②根据反码求原码：最高位不变，其他位取反
            反码1111 1111 1111 1111 1111 1111 1111 1001转换为原码是1000 0000 0000 0000 0000 0000 0000 0110
            4.将原码转换为十进制
            打印输出结果是十进制
            1000 0000 0000 0000 0000 0000 0000 0110转换为十进制结果是-6
            5. 最终结果就是~5 = -6

         */
        System.out.println("~5 = " + (~5));
    }
}

3. 运行BitNotOperatorPositiveNumberExample1

程序运行结果

1.5.1.2 按位取反运算符操作正整数之~10

1. 新建源文件BitNotOperatorPositiveNumberExample2.java

2. 编辑源文件BitNotOperatorPositiveNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位取反运算符操作正整数之~10
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 14:51
 * @since Java21
 */
public class BitNotOperatorPositiveNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算10的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            5的补码：0000 0000 0000 0000 0000 0000 0000 1010

            2.计算~10
            按位与计算规则是按照二进制位取反：1为0，0为1
            0000 0000 0000 0000 0000 0000 0000 1010
            ~
            =
            1111 1111 1111 1111 1111 1111 1111 0101
            3.将补码换算成原码
            查看运算结果看原码,负数的原码是补码减1取反
            ①根据补码求反码：反码=补码减1
            1111 1111 1111 1111 1111 1111 1111 0101-1=1111 1111 1111 1111 1111 1111 1111 0100
            ②根据反码求原码：最高位不变，其他位取反
            反码1111 1111 1111 1111 1111 1111 1111 0100转换为原码是1000 0000 0000 0000 0000 0000 0000 1011
            4.将原码转换为十进制
            打印输出结果是十进制
            1000 0000 0000 0000 0000 0000 0000 1011转换为十进制结果是-11
            5. 最终结果就是~10 = -11

         */
        System.out.println("~10 = " + (~10));
    }
}

3. 运行BitNotOperatorPositiveNumberExample2

程序运行结果

1.5.2 按位取反运算符操作负整数

1.5.2.1 按位取反运算符操作负整数之 ~-5

1. 新建源文件BitNotOperatorNegativeNumberExample1.java

2. 编辑源文件BitNotOperatorNegativeNumberExample1.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位取反运算符操作负整数之~-5
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 14:55
     * @since Java21
     */
    public class BitNotOperatorNegativeNumberExample1 {
        public static void main(String[] args) {
            /*
                1.先计算-5的补码
                计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
                ①求5的原码
                5的原码：0000 0000 0000 0000 0000 0000 0000 0101
                ②求-5的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
                -5的原码：1000 0000 0000 0000 0000 0000 0000 0101
                ③求-5的反码（原码求反码：最高位不变，其他位取反）
                -5的反码：1111 1111 1111 1111 1111 1111 1111 1010
                ④求-5的补码（补码=反码+1）
                -5的补码：1111 1111 1111 1111 1111 1111 1111 1011
                2.计算~-5
                按位与计算规则是按照二进制位取反：1为0，0为1
                1111 1111 1111 1111 1111 1111 1111 1011
                ~
                =
                0000 0000 0000 0000 0000 0000 0000 0100
                3.将补码换算成原码（根据补码求原码）
                补码0000 0000 0000 0000 0000 0000 0000 0100转换成原码是0000 0000 0000 0000 0000 0000 0000 0100
                4.将原码转换为十进制（ 打印输出结果是十进制）
                0000 0000 0000 0000 0000 0000 0000 0100转换为十进制结果是4
                5. 最终结果就是~-5 = 4
             */
            System.out.println("~-5 = " + (~-5));
        }
    }

3. 运行BitNotOperatorNegativeNumberExample1

程序运行结果

1.5.2.2 按位取反运算符操作负整数之~-10

1. 新建源文件BitNotOperatorNegativeNumberExample2.java

2. 编辑源文件BitNotOperatorNegativeNumberExample2

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 按位取反运算符操作负整数之~-10
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 15:02
 * @since Java21
 */
public class BitNotOperatorNegativeNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算-10的补码
            计算机中的数据是使用补码进行运算的，负数的补码等于原码取反加1
            ①求10的原码
            10的原码：0000 0000 0000 0000 0000 0000 0000 1010
            ②求-10的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -10的原码：1000 0000 0000 0000 0000 0000 0000 1010
            ③求-10的反码（原码求反码：最高位不变，其他位取反）
            -10的反码：1111 1111 1111 1111 1111 1111 1111 0101
            ④求-10的补码（补码=反码+1）
            -10的补码：1111 1111 1111 1111 1111 1111 1111 0110
            2.计算~-10
            按位与计算规则是按照二进制位取反：1为0，0为1
            1111 1111 1111 1111 1111 1111 1111 0110
            ~
            =
            0000 0000 0000 0000 0000 0000 0000 1001
            3.将补码换算成原码（根据补码求原码）
            补码0000 0000 0000 0000 0000 0000 0000 1001转换成原码是0000 0000 0000 0000 0000 0000 0000 1001
            4.将原码转换为十进制（ 打印输出结果是十进制）
            0000 0000 0000 0000 0000 0000 0000 1001转换为十进制结果是9
            5. 最终结果就是~-10 = 9
         */
        System.out.println("~-10 = " + (~-10));
    }
}

3. 运行BitNotOperatorNegativeNumberExample2

程序运行结果

1.6 左移运算符

1.6.1 左移运算符操作正整数

1.6.1.1 左移运算符操作正整数之8 << 1

1. 新建源文件LeftShiftBitOperatorPositiveNumberExample1.java

2. 编辑源文件LeftShiftBitOperatorPositiveNumberExample1.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 左移运算符操作正整数之8 << 1
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 15:27
     * @since Java21
     */
    public class LeftShiftBitOperatorPositiveNumberExample1 {
        public static void main(String[] args) {
            /*
                1.先计算8的补码
                计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
                8的补码：0000 0000 0000 0000 0000 0000 0000 1000
                2.计算8 << 1
                左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方
                0000 0000 0000 0000 0000 0000 0000 1000
                << 1
                =
                000 0000 0000 0000 0000 0000 0000 10000
    
                3.将补码换算成原码
                查看运算结果看原码,正数的原码、反码、补码都一样
                补码000 0000 0000 0000 0000 0000 0000 10000转换为原码是000 0000 0000 0000 0000 0000 0000 10000
                4.将原码转换为十进制
                打印输出结果是十进制
                000 0000 0000 0000 0000 0000 0000 10000转换为十进制结果是16
                5. 最终结果就是8 << 1 = 16
             */
            System.out.println("8 << 1 = " + (8 << 1));
        }
    }
    

3. 运行LeftShiftBitOperatorPositiveNumberExample1

程序运行结果

1.6.1.2 左移运算符操作正整数之8 << 2

1. 新建源文件LeftShiftBitOperatorPositiveNumberExample2.java

2. 编辑源文件LeftShiftBitOperatorPositiveNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 左移运算符操作正整数之8 << 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 15:46
 * @since Java21
 */
public class LeftShiftBitOperatorPositiveNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 << 2
            左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方
            0000 0000 0000 0000 0000 0000 0000 1000
            << 2
            =
            00 0000 0000 0000 0000 0000 0000 100000

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码00 0000 0000 0000 0000 0000 0000 100000转换为原码是00 0000 0000 0000 0000 0000 0000 100000
            4.将原码转换为十进制
            打印输出结果是十进制
            00 0000 0000 0000 0000 0000 0000 100000转换为十进制结果是32
            5. 最终结果就是8 << 2 = 32
         */
        System.out.println("8 << 2 = " + (8 << 2));
    }
}

3. 运行LeftShiftBitOperatorPositiveNumberExample2

程序运行结果

1.6.1.3 左移运算符操作正整数之8 << 28

1. 新建源文件LeftShiftBitOperatorPositiveNumberExample3.java

2. 编辑源文件LeftShiftBitOperatorPositiveNumberExample3.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 左移运算符操作正整数之8 << 28
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 16:03
 * @since Java21
 */
public class LeftShiftBitOperatorPositiveNumberExample3 {
    public static void main(String[] args) {
         /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 << 28
            左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方
            0000 0000 0000 0000 0000 0000 0000 1000
            << 28
            =
            1000 0000 0000 0000 0000 0000 0000 0000
            1000 0000 0000 0000 0000 0000 0000 0000是-2147483648的补码，并且没有原码和反码

            3. 最终结果就是8 << 28 = -2147483648
         */
        System.out.println("8 << 28 = " + (8 << 28));

    }
}

3. 运行LeftShiftBitOperatorPositiveNumberExample3

程序运行结果

计算器验证补码10000000000000000000000000000000对应的十进制也是-2147483648

1.6.2 左移运算符操作负整数

1.6.2.1 左移运算符操作负整数之-8 << 1

1. 新建源文件LeftShiftBitOperatorNegativeNumberExample1.java

2. 编辑源文件LeftShiftBitOperatorNegativeNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 左移运算符操作负整数之-8 << 1
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:00
 * @since Java21
 */
public class LeftShiftBitOperatorNegativeNumberExample1 {
    public static void main(String[] args) {
         /*
            1.先求-8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求8的原码
            8的原码：0000 0000 0000 0000 0000 0000 0000 1000
            ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
            ③求-8的反码（原码求反码：最高位不变，其他位取反）
           -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
            ④求-8的补码（补码=反码+1）
           -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
            2.计算-8 << 1
            左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方
            1111 1111 1111 1111 1111 1111 1111 1000
            << 1
            =
            111 1111 1111 1111 1111 1111 1111 10000

            3.将补码换算成原码（根据补码求原码）
            查看运算结果看原码,原码等于补码减1取反
            ①根据补码求反码：反码=补码-1
            111 1111 1111 1111 1111 1111 1111 10000-1=111 1111 1111 1111 1111 1111 1111 01111
            ②根据反码求原码：最高位不变，其他位取反
            反码111 1111 1111 1111 1111 1111 1111 01111转换为原码是100 0000 0000 0000 0000 0000 0000 10000
            4.将原码转换为十进制
            打印输出结果是十进制
            100 0000 0000 0000 0000 0000 0000 10000转换为十进制结果是-16
            5. 最终结果就是-8 << 1 = -16
         */
        System.out.println("-8 << 1 = " + (-8 << 1));

    }
}

3. 运行LeftShiftBitOperatorNegativeNumberExample1

程序运行结果

1.6.2.2 左移运算符操作负整数之-8 << 2

1. 新建源文件LeftShiftBitOperatorNegativeNumberExample2.java

2. 编辑源文件LeftShiftBitOperatorNegativeNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 左移运算符操作负整数之-8 << 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:20
 * @since Java21
 */
public class LeftShiftBitOperatorNegativeNumberExample2 {
    public static void main(String[] args) {
        /*
            1.先求-8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求8的原码
            8的原码：0000 0000 0000 0000 0000 0000 0000 1000
            ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
            ③求-8的反码（原码求反码：最高位不变，其他位取反）
           -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
            ④求-8的补码（补码=反码+1）
           -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
            2.计算-8 << 2
            左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方
            1111 1111 1111 1111 1111 1111 1111 1000
            << 2
            =
            11 1111 1111 1111 1111 1111 1111 100000

            3.将补码换算成原码（根据补码求原码）
            查看运算结果看原码,原码等于补码减1取反
            ①根据补码求反码：反码=补码-1
            11 1111 1111 1111 1111 1111 1111 100000-1=11 1111 1111 1111 1111 1111 1111 011111
            ②根据反码求原码：最高位不变，其他位取反
            反码11 1111 1111 1111 1111 1111 1111 011111转换为原码是10 0000 0000 0000 0000 0000 0000 100000
            4.将原码转换为十进制
            打印输出结果是十进制
            10 0000 0000 0000 0000 0000 0000 100000转换为十进制结果是-32
            5. 最终结果就是-8 << 2 = -32
         */
        System.out.println("-8 << 2 = " + (-8 << 2));
    }
}

3. 运行LeftShiftBitOperatorNegativeNumberExample2

程序运行结果

1.6.2.3 左移运算符操作负整数之-8 << 28

1. 新建源文件LeftShiftBitOperatorNegativeNumberExample3.java

2. 编辑源文件LeftShiftBitOperatorNegativeNumberExample3.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 左移运算符操作负整数之-8 << 28
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:25
 * @since Java21
 */
public class LeftShiftBitOperatorNegativeNumberExample3 {
    public static void main(String[] args) {
        /*
            1.先求-8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求8的原码
            8的原码：0000 0000 0000 0000 0000 0000 0000 1000
            ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
            ③求-8的反码（原码求反码：最高位不变，其他位取反）
           -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
            ④求-8的补码（补码=反码+1）
           -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
            2.计算-8 << 28
            左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方
            1111 1111 1111 1111 1111 1111 1111 1000
            << 28
            =
            1000 0000 0000 0000 0000 0000 0000 0000
            1000 0000 0000 0000 0000 0000 0000 0000是-2147483648的补码，并且没有原码和反码
            3. 最终结果就是-8 << 28 = -2147483648

         */
        System.out.println("-8 << 28 = " + (-8 << 28));
    }
}

3. 运行LeftShiftBitOperatorNegativeNumberExample3

程序运行结果

1.7 右移运算符

1.7.1 右移运算符操作正整数

1.7.1.1 右移运算符操作正整数之8 >> 1

1. 新建源文件RightShiftBitOperatorPositiveNumberExample1.java

2. 编辑源文件RightShiftBitOperatorPositiveNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 右移运算符操作正整数之8 >> 1
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:30
 * @since Java21
 */
public class RightShiftBitOperatorPositiveNumberExample1 {
    public static void main(String[] args) {
          /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 >> 1
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。
            右移n位在一定范围内就是除以2的n次方。
            0000 0000 0000 0000 0000 0000 0000 1000
            >> 1
            =
            00000 0000 0000 0000 0000 0000 0000 100

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码00000 0000 0000 0000 0000 0000 0000 100转换为原码是00000 0000 0000 0000 0000 0000 0000 100
            4.将原码转换为十进制
            打印输出结果是十进制
            00000 0000 0000 0000 0000 0000 0000 100转换为十进制结果是4
            5. 最终结果就是8 >> 1 = 4
         */
        System.out.println("8 >> 1 = " + (8 >> 1));
    }
}

3. 运行RightShiftBitOperatorPositiveNumberExample1

程序运行结果

1.7.1.2 右移运算符操作正整数之8 >> 2

1. 新建源文件RightShiftBitOperatorPositiveNumberExample2.java

2. 编辑源文件RightShiftBitOperatorPositiveNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 右移运算符操作正整数之8 >> 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:35
 * @since Java21
 */
public class RightShiftBitOperatorPositiveNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 >> 2
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。
            右移n位在一定范围内就是除以2的n次方。
            0000 0000 0000 0000 0000 0000 0000 1000
            >> 2
            =
            000000 0000 0000 0000 0000 0000 0000 10

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码000000 0000 0000 0000 0000 0000 0000 10转换为原码是000000 0000 0000 0000 0000 0000 0000 10
            4.将原码转换为十进制
            打印输出结果是十进制
            000000 0000 0000 0000 0000 0000 0000 10转换为十进制结果是2
            5. 最终结果就是8 >> 2 = 2
         */
        System.out.println("8 >> 2 = " + (8 >> 2));
    }
}

3. 运行RightShiftBitOperatorPositiveNumberExample2

程序运行结果

1.7.1.3 右移运算符操作正整数之8 >>4

1. 新建源文件RightShiftBitOperatorPositiveNumberExample3.java

2. 编辑源文件RightShiftBitOperatorPositiveNumberExample3.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 右移运算符操作正整数之8 >> 4
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:38
 * @since Java21
 */
public class RightShiftBitOperatorPositiveNumberExample3 {
    public static void main(String[] args) {
          /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 >> 28
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。
            右移n位在一定范围内就是除以2的n次方。
            0000 0000 0000 0000 0000 0000 0000 1000
            >> 2
            =
            0000 0000 0000 0000 0000 0000 0000 0000

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码 0000 0000 0000 0000 0000 0000 0000 0000转换为原码是 0000 0000 0000 0000 0000 0000 0000 0000
            4.将原码转换为十进制
            打印输出结果是十进制
             0000 0000 0000 0000 0000 0000 0000 0000转换为十进制结果是0
            5. 最终结果就是8 >> 4 = 0
         */
        System.out.println("8 >> 4 = " + (8 >> 4));
    }
}

3. 运行RightShiftBitOperatorPositiveNumberExample3

程序运行结果

1.7.2 右移运算符操作负整数

1.7.2.1 右移运算符操作负整数之-8 >> 1

1. 新建源文件RightShiftBitOperatorNegativeNumberExample1.java

2. 编辑源文件RightShiftBitOperatorNegativeNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 右移运算符操作负整数之-8 >> 1
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:42
 * @since Java21
 */
public class RightShiftBitOperatorNegativeNumberExample1 {
    public static void main(String[] args) {
         /*
            1.先求-8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求8的原码
            8的原码：0000 0000 0000 0000 0000 0000 0000 1000
            ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
            ③求-8的反码（原码求反码：最高位不变，其他位取反）
           -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
            ④求-8的补码（补码=反码+1）
           -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
            2.计算-8 >> 1
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。
            右移n位在一定范围内就是除以2的n次方。
            1111 1111 1111 1111 1111 1111 1111 1000
            >> 1
            =
            11111 1111 1111 1111 1111 1111 1111 100

            3.将补码换算成原码（根据补码求原码）
            查看运算结果看原码,原码等于补码减1取反
            ①根据补码求反码：反码=补码-1
            11111 1111 1111 1111 1111 1111 1111 100-1=11111 1111 1111 1111 1111 1111 1111 011
            ②根据反码求原码：最高位不变，其他位取反
            反码11111 1111 1111 1111 1111 1111 1111 011转换为原码是10000 0000 0000 0000 0000 0000 0000 100
            4.将原码转换为十进制
            打印输出结果是十进制
            10000 0000 0000 0000 0000 0000 0000 100转换为十进制结果是-4
            5. 最终结果就是-8 >> 1 = -4
         */
        System.out.println("-8 >> 1 = " + (-8 >> 1));
    }
}

3. 运行RightShiftBitOperatorNegativeNumberExample1

程序运行结果

1.7.2.2 右移运算符操作负整数之-8 >> 2

1. 新建源文件RightShiftBitOperatorNegativeNumberExample2.java

2. 编辑源文件RightShiftBitOperatorNegativeNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 右移运算符操作负整数之-8 >> 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 18:48
 * @since Java21
 */
public class RightShiftBitOperatorNegativeNumberExample2 {
    public static void main(String[] args) {
        /*
            1.先求-8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求8的原码
            8的原码：0000 0000 0000 0000 0000 0000 0000 1000
            ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
            ③求-8的反码（原码求反码：最高位不变，其他位取反）
           -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
            ④求-8的补码（补码=反码+1）
           -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
            2.计算-8 >> 2
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。
            右移n位在一定范围内就是除以2的n次方。
            1111 1111 1111 1111 1111 1111 1111 1000
            >> 2
            =
            111111 1111 1111 1111 1111 1111 1111 10

            3.将补码换算成原码（根据补码求原码）
            查看运算结果看原码,原码等于补码减1取反
            ①根据补码求反码：反码=补码-1
            111111 1111 1111 1111 1111 1111 1111 10-1=111111 1111 1111 1111 1111 1111 1111 01
            ②根据反码求原码：最高位不变，其他位取反
            反码111111 1111 1111 1111 1111 1111 1111 01转换为原码是100000 0000 0000 0000 0000 0000 0000 10
            4.将原码转换为十进制
            打印输出结果是十进制
            100000 0000 0000 0000 0000 0000 0000 10转换为十进制结果是-2
            5. 最终结果就是-8 >> 2 = -2
         */
        System.out.println("-8 >> 2 = " + (-8 >> 2));
    }
}

3. 运行RightShiftBitOperatorNegativeNumberExample2

程序运行结果

1.7.2.3 右移运算符操作负整数之-8 >> 4

1. 新建源文件RightShiftBitOperatorNegativeNumberExample3.java

2. 编辑源文件RightShiftBitOperatorNegativeNumberExample3.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 右移运算符操作负整数之-8 >> 4
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 18:54
     * @since Java21
     */
    public class RightShiftBitOperatorNegativeNumberExample3 {
        public static void main(String[] args) {
               /*
                1.先求-8的补码
                计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
                ①求8的原码
                8的原码：0000 0000 0000 0000 0000 0000 0000 1000
                ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
               -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
                ③求-8的反码（原码求反码：最高位不变，其他位取反）
               -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
                ④求-8的补码（补码=反码+1）
               -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
                2.计算-8 >> 4
                右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充符号位，符号位是0填充0，符号位是1就填充1。
                右移n位在一定范围内就是除以2的n次方。
                1111 1111 1111 1111 1111 1111 1111 1000
                >> 4
                =
                1111 1111 1111 1111 1111 1111 1111 1111
                3.将补码换算成原码（根据补码求原码）
                ①根据补码求反码：补码-1=反码
                1111 1111 1111 1111 1111 1111 1111 1111-1=1111 1111 1111 1111 1111 1111 1111 1110
                ②根据反码求原码：最高位不变，其他位取反
                1111 1111 1111 1111 1111 1111 1111 1110转换为原码是1000 0000 0000 0000 0000 0000 0000 0001
                4.将原码转换为十进制
                打印输出结果是十进制
                1000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是-1
                5. 最终结果就是-8 >> 4 = -1
    
             */
            System.out.println("-8 >> 4 = " + (-8 >> 4));
        }
    }
    

3. 运行RightShiftBitOperatorNegativeNumberExample3

程序运行结果

1.8 无符号右移运算符

1.8.1 无符号右移运算符操作正整数

1.8.1.1 无符号右移运算符操作正整数之8 >>> 1

1. 新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample1.java

2. 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 无符号右移运算符操作正整数之8 >>> 1
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 19:12
 * @since Java21
 */
public class UnsignedRightShiftBitOperatorPositiveNumberExample1 {
    public static void main(String[] args) {
          /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 >>> 1
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充0
            0000 0000 0000 0000 0000 0000 0000 1000
            >>> 1
            =
            00000 0000 0000 0000 0000 0000 0000 100

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码00000 0000 0000 0000 0000 0000 0000 100转换为原码是00000 0000 0000 0000 0000 0000 0000 100
            4.将原码转换为十进制
            打印输出结果是十进制
            00000 0000 0000 0000 0000 0000 0000 100转换为十进制结果是4
            5. 最终结果就是8 >>> 1 = 4
         */
        System.out.println("8 >>> 1 = " + (8 >>> 1));
    }
}

3. 运行UnsignedRightShiftBitOperatorPositiveNumberExample1

程序运行结果

1.8.1.2 无符号右移运算符操作正整数之8 >>> 2

1. 新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java

2. 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 无符号右移运算符操作正整数之8 >>> 2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 19:16
 * @since Java21
 */
public class UnsignedRightShiftBitOperatorPositiveNumberExample2 {
    public static void main(String[] args) {
         /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 >>> 2
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充0
            0000 0000 0000 0000 0000 0000 0000 1000
            >>> 2
            =
            000000 0000 0000 0000 0000 0000 0000 10

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码000000 0000 0000 0000 0000 0000 0000 10转换为原码是000000 0000 0000 0000 0000 0000 0000 10
            4.将原码转换为十进制
            打印输出结果是十进制
            000000 0000 0000 0000 0000 0000 0000 10转换为十进制结果是2
            5. 最终结果就是8 >>> 2 = 2
         */
        System.out.println("8 >>> 2 = " + (8 >>> 2));
    }
}

3. 运行UnsignedRightShiftBitOperatorPositiveNumberExample2

程序运行结果

1.8.1.3 无符号右移运算符操作正整数之8 >>> 4

1. 新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java

2. 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 无符号右移运算符操作正整数之8 >>> 4
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 19:20
 * @since Java21
 */
public class UnsignedRightShiftBitOperatorPositiveNumberExample3 {
    public static void main(String[] args) {
         /*
            1.先计算8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样
            8的补码：0000 0000 0000 0000 0000 0000 0000 1000
            2.计算8 >>> 4
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充0
            0000 0000 0000 0000 0000 0000 0000 1000
            >>> 4
            =
            0000 0000 0000 0000 0000 0000 0000 0000

            3.将补码换算成原码
            查看运算结果看原码,正数的原码、反码、补码都一样
            补码0000 0000 0000 0000 0000 0000 0000 0000转换为原码是0000 0000 0000 0000 0000 0000 0000 0000
            4.将原码转换为十进制
            打印输出结果是十进制
            0000 0000 0000 0000 0000 0000 0000 0000转换为十进制结果是0
            5. 最终结果就是8 >>> 4 = 0
         */
        System.out.println("8 >>> 4 = " + (8 >>> 4));
    }
}

3. 运行UnsignedRightShiftBitOperatorPositiveNumberExample3

程序运行结果

1.8.2 无符号右移运算符操作负整数

1.8.2.1 无符号右移运算符操作负整数之-8 >>> 1

1. 新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample1.java

2. 编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample1.java

package net.ittimeline.java.core.foundational.operator.bit;

/**
 * 无符号右移运算符操作负整数之-8 >>> 1
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 19:24
 * @since Java21
 */
public class UnsignedRightShiftBitOperatorNegativeNumberExample1 {
    public static void main(String[] args) {
         /*
            1.先求-8的补码
            计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
            ①求8的原码
            8的原码：0000 0000 0000 0000 0000 0000 0000 1000
            ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
           -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
            ③求-8的反码（原码求反码：最高位不变，其他位取反）
           -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
            ④求-8的补码（补码=反码+1）
           -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
            2.计算-8 >>> 1
            右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充0
            1111 1111 1111 1111 1111 1111 1111 1000
            >>> 1
            =
            01111 1111 1111 1111 1111 1111 1111 100

            3.将补码换算成原码（根据补码求原码）
            补码01111 1111 1111 1111 1111 1111 1111 100转换成原码是01111 1111 1111 1111 1111 1111 1111 100
            4.将原码转换为十进制
            打印输出结果是十进制
            01111 1111 1111 1111 1111 1111 1111 100转换为十进制结果是2147483644
            5. 最终结果就是-8 >>> 1 = 2147483644
         */
        System.out.println("-8 >>> 1 = " + (-8 >>> 1));
    }
}

3. 运行UnsignedRightShiftBitOperatorNegativeNumberExample1

程序运行结果

1.8.2.2 无符号右移运算符操作负整数之-8 >>> 2

1. 新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java

2. 编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 无符号右移运算符操作负整数之-8 >>> 2
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 19:29
     * @since Java21
     */
    public class UnsignedRightShiftBitOperatorNegativeNumberExample2 {
        public static void main(String[] args) {
             /*
                1.先求-8的补码
                计算机中的数据是使用补码进行运算的，正数的原码、反码、补码都一样，负数的补码等于原码取反加1
                ①求8的原码
                8的原码：0000 0000 0000 0000 0000 0000 0000 1000
                ②求-8的原码（原码的最高位（左边的第一位）是符号位：0表示正数，1表示负数）
               -8的原码：1000 0000 0000 0000 0000 0000 0000 1000
                ③求-8的反码（原码求反码：最高位不变，其他位取反）
               -8的反码：1111 1111 1111 1111 1111 1111 1111 0111
                ④求-8的补码（补码=反码+1）
               -8的补码：1111 1111 1111 1111 1111 1111 1111 1000
                2.计算-8 >>> 2
                右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充0
                1111 1111 1111 1111 1111 1111 1111 1000
                >>> 1
                =
                00111 1111 1111 1111 1111 1111 1111 100
    
                3.将补码换算成原码（根据补码求原码）
                补码00111 1111 1111 1111 1111 1111 1111 100转换成原码是00111 1111 1111 1111 1111 1111 1111 100
                4.将原码转换为十进制
                打印输出结果是十进制
                00111 1111 1111 1111 1111 1111 1111 100转换为十进制结果是1073741820
                5. 最终结果就是-8 >>> 2 =1073741820
             */
            System.out.println("-8 >>> 2 = " + (-8 >>> 2));
        }
    }

3. 运行UnsignedRightShiftBitOperatorNegativeNumberExample2

程序运行结果

2. 赋值运算符

2.1 赋值运算符介绍

Java语言中的等号(=)表示赋值，用于将等号(=)右边的值赋值给左边的变量，值可以是字面量、变量或者是表达式。

变量的首次赋值也被称为变量的初始化，而当变量多次被赋值后，新值会覆盖旧值。

int number = 10;
//第二次赋值时新值会覆盖旧值
number = 20;

当赋值号（=）两边数据类型不一致时，可以使用自动类型转换或者是强制类型转换进行处理。

double doubleValue = 5;
long longValue = 10;

int intValue = (int) 180.05;
byte byteValue = (byte) intValue;

Java支持连续赋值，即同时给多个变量赋相同运算的值

int left;
int right;
//int left;和int right;等价于 int left,right;
left = right = 10;

也可以通过逗号运算符同时给多个变量赋不同的值

int left=10,right =20;

赋值表达式本身也是有值，其值就是给变量赋的值。

int value = 10;
System.out.println("赋值表达式value=100的结果是 " + (value = 100));

赋值运算符还可以结合算术运算符、位运算符使用，组成扩展赋值运算符

赋值运算符结合算术运算符

扩展赋值运算符	说明
+=	将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
-=	将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
*=	将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
/=	将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
%=	将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

赋值运算符结合位运算符

扩展赋值运算符	说明
&=	将符号左边的值和右边的值进行按位与操作，最后将结果赋值给左边的变量
|=	将符号左边的值和右边的值进行按位或操作，最后将结果赋值给左边的变量
^=	将符号左边的值和右边的值进行按位异或操作，最后将结果赋值给左边的变量
<<=	将符号左边的值和右边的值进行左移操作，最后将结果赋值给左边的变量
>>=	将符号左边的值和右边的值进行右移操作，最后将结果赋值给左边的变量
>>>=	将符号左边的值和右边的值进行无符号右移操作，最后将结果赋值给左边的变量

2.2 赋值运算符使用

2.2.1 赋值运算符基本使用

1. 新建包

2. 新建源文件AssignmentOperatorUsage.java

3. 编辑源文件AssignmentOperatorUsage.java

package net.ittimeline.java.core.foundational.operator.assignment;

/**
 * 基本赋值运算符的使用
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 19:45
 * @since Java21
 */
public class AssignmentOperatorUsage {
    public static void main(String[] args) {
        //赋值运算符使用方式1
        System.out.println("1.赋值运算符使用方式1");
        int number = 10;
        System.out.println("number = " + number);
        //第二次赋值时新值会覆盖旧值
        number = 20;
        System.out.println("number = " + number);

        //当=两侧数据类型不一致，可以使用自动类型转换或者使用强制类型转换原则进行处理
        double doubleValue = 5;
        System.out.println("doubleValue = " + doubleValue);
        long longValue = 10;

        int intValue = (int) 180.05;
        System.out.println("intValue = " + intValue);
        byte byteValue = (byte) intValue;
        System.out.println("byteValue = " + byteValue);
        //连续赋值
        int left;
        int right;
        //36行和37行 等价于 int left,right;
        left = right = 10;
        System.out.printf("连续赋值 left=%d right=%d\n", left, right);
        //赋值运算符使用方式2
        int x = 10, y = 20, z = 30;
        System.out.println("x = " + x);
        System.out.println("y = " + y);
        System.out.println("z = " + z);
        //赋值表达式本身也是有值，其值就是给变量赋的值。
        int value = 10;
        System.out.println("赋值表达式value=100的结果是 " + (value = 100));
    }
}

4. 运行AssignmentOperatorUsage

程序运行结果

2.2.2 扩展赋值运算符基本使用

1. 新建源文件ExtendsAssignmentOperatorUsage.java

2. 编辑源文件ExtendsAssignmentOperatorUsage.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 扩展赋值运算符使用
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 19:53
     * @since Java21
     */
    public class ExtendsAssignmentOperatorUsage {
        public static void main(String[] args) {
            System.out.println("一.赋值运算符和算术运算符结合使用");
            int number = 100;
            System.out.println("1.number = " + number);
            number += 10;
            System.out.println("2.number += 10  number = " + number);
            number -= 20;
            System.out.println("3.number -= 20  number = " + number);
            number *= 5;
            System.out.println("4.number *= 5  number = " + number);
            number /= 3;
            System.out.println("5.number /= 3  number = " + number);
            number %= 150;
            System.out.println("6.number %= 150  number = " + number);
            System.out.println("二.赋值运算符和位运算符结合使用");
            int left = 10;
            int right = 8;
            System.out.println("1.left = " + left + " right = " + right);
            left &= right;
            System.out.println("2.left &= right  left = " + left + " right = " + right);
            left |= right;
            System.out.println("3.left |= right  left = " + left + " right = " + right);
            left ^= right;
            System.out.println("4.left ^= right  left = " + left + " right = " + right);
            right <<= 2;
            System.out.println("5.right <<= 2  left = " + left + " right = " + right);
            right >>= 2;
            System.out.println("6.right <<= 2  left = " + left + " right = " + right);
            right >>>= 3;
            System.out.println("7.right >>>= 3  left = " + left + " right = " + right);
    
        }
    }

3. 运行ExtendsAssignmentOperatorUsage

程序运行结果

2.3 赋值运算符使用注意事项

2.3.1赋值运算符使用注意事项1

赋值运算符的运算顺序是从右往左

1. 新建源文件AssignmentOperatorWarning1.java

2. 编辑源文件AssignmentOperatorWarning1.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 赋值运算符注意事项1
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 20:14
     * @since Java21
     */
    public class AssignmentOperatorWarning1 {
        public static void main(String[] args) {
            //1.赋值运算符的运算顺序是从右往左
            int left, middle, right;
            left = middle = right = 100;
            System.out.println("left = " + left);
            System.out.println("middle = " + middle);
            System.out.println("right = " + right);
        }
    }

3. 运行AssignmentOperatorWarning1

程序运行结果

2.3.2 赋值运算符使用注意事项2

赋值运算符的左边只能是变量，右边可以是字面量、变量或者表达式

1. 新建源文件AssignmentOperatorWarning2.java

2. 编辑源文件AssignmentOperatorWarning2.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 赋值运算符注意事项2
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 20:16
     * @since Java21
     */
    public class AssignmentOperatorWarning2 {
        public static void main(String[] args) {
    
            //2. 赋值运算符的左边只能是变量，右边可以是字面量、变量或者表达式
            int number = 10;
            System.out.println("赋值的时候右边是字面量 number = " + number);
            // 赋值的时候左边必须是变量 否则编译错误
            10 = 10;
            10 = number;
    
            //赋值的时候右边必须是字面值、变量、表达式
            int value = 20;
            number = value;
            System.out.println("赋值的时候右边是变量 number = " + number);
            number = value / 2;
            System.out.println("赋值的时候右边是算术表达式 number = " + number);
        }
    }
    

3. 运行AssignmentOperatorWarning2

运行之前将第17行和第18行编译错误的地方注释

程序运行结果

2.3.3 赋值运算符使用注意事项3

复合赋值运算符不会改变变量的数据类型

1. 新建源文件AssignmentOperatorWarning3.java

2. 编辑源文件AssignmentOperatorWarning3.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 赋值运算符使用注意事项3
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 20:19
     * @since Java21
     */
    public class AssignmentOperatorWarning3 {
        public static void main(String[] args) {
            //复合赋值运算符不会改变变量的数据类型
            byte byteVar = 10;
            //等价于byteVar =(byte) (byteVar+10)
            byteVar += 10;
            System.out.println("byteVar = " + byteVar);
            //自增运算符底层也会进行类型转换
            byteVar++;
    
            int m = 1;
            // m = m * 0.1 等价于 m = (int)(m * 0.1)
            m *= 0.1;
            System.out.println("m = " + m);
        }
    }

3. 运行AssignmentOperatorWarning3

程序运行结果

2.4 赋值运算符案例

2.4.1 实现变量值加1

1. 新建源文件AssignmentOperatorExample1.java

2. 编辑源文件AssignmentOperatorExample1.java

package net.ittimeline.java.core.foundational.operator.assignment;

/**
 * 算术运算符案例1：实现变量值加1
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 20:26
 * @since Java21
 */
public class AssignmentOperatorExample1 {
    public static void main(String[] args) {
        //方式1：
        int type1 = 1;
        type1 += 1;
        System.out.println("type1 = " + type1);

        //方式2：
        int type2 = 1;
        type2 = type2 + 1;
        System.out.println("type2 = " + type2);

        //方式3：推荐
        int type3 = 1;
        type3++;
        System.out.println("type3 = " + type3);
        //方式4：
        int type4 = 1;
        ++type4;
        System.out.println("type4 = " + type4);
    }
}

3. 运行AssignmentOperatorExample1

程序运行结果

2.4.2 实现变量值加2

1. 新建源文件AssignmentOperatorExample2.java

2. 编辑源文件AssignmentOperatorExample2.java

package net.ittimeline.java.core.foundational.operator.assignment;

/**
 * 赋值运算符案例2：实现变量值加2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/2 20:29
 * @since Java21
 */
public class AssignmentOperatorExample2 {
    public static void main(String[] args) {
        //方式1：推荐
        int type1 = 1;
        type1 += 2;
        System.out.println("type1 = " + type1);
        //方式2：
        int type2 = 1;
        type2 = type2 + 2;
        System.out.println("type2 = " + type2);
    }
}

3. 运行AssignmentOperatorExample2

程序运行结果

3. 三种数据交换的方式

Q：什么时候会使用到数据交换

A：使用排序算法（例如冒泡排序、选择排序）等相关算法时会使用到变量交换

3.1 使用临时变量实现数据交换

优点：简单、适用性好(基本数据类型、引用数据类型都适用)

缺点：需要开辟临时空间

1. 新建源文件DataExchangeWithTemp.java

2. 编辑源文件DataExchangeWithTemp.java

   package net.ittimeline.java.core.foundational.operator;
    
    /**
     * 数据交换实现方式1：使用临时变量实现数据交换
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 20:34
     * @since Java21
     */
    public class DataExchangeWithTemp {
        public static void main(String[] args) {
            int left = 10;
            int right = 20;
            System.out.println("数据交换实现方式1:使用临时变量实现交换之前");
            System.out.printf("left = %d  right = %d \n", left, right);
    
            //使用临时变量交换
            //优点：简单、适用性好
            //缺点：需要开辟临时空间
            //① temp = 10 ② left =10
            int temp = left;
            //① right = 20 ② left =20
            left = right;
            //① temp = 10 ② right =10
            right = temp;
            System.out.println("数据交换实现方式1:基于临时变量实现交换之后");
            System.out.printf("left = %d  right = %d \n", left, right);
        }
    }
    

3. 运行DataExchangeWithTemp

程序运行结果

3.2 使用算术运算实现数据交换

优势：不需要开辟临时空间

缺点：适用性差（不支持非数值类型）、可能超出int类型的范围

1. 新建源文件DataExchangeWithArithmeticOperator.java

2. 编辑源文件DataExchangeWithArithmeticOperator.java

 package net.ittimeline.java.core.foundational.operator;
    
    /**
     * 数据交换实现方式2：使用算术运算实现数据交换
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 20:39
     * @since Java21
     */
    public class DataExchangeWithArithmeticOperator {
        public static void main(String[] args) {
            int left = 10;
            int right = 20;
            System.out.println("数据交换的实现方式2:使用算术运算(加减法)实现交换之前");
            System.out.printf("left = %d  right = %d \n", left, right);
    
            //使用算术运算交换
            //优点：不需要临时变量节省空间
            //缺点：适用性差（不支持非数值类型）、可能超出int类型的范围
            //left = 10 + 20
            left = left + right;
            //right = 10
            right = left - right;
            //left = 30 - 10
            left = left - right;
            System.out.println("数据交换实现方式2:使用算术运算(加减法)实现交换之后");
            System.out.printf("left = %d  right = %d \n", left, right);
        }
    }

3. 运行DataExchangeWithArithmeticOperator

程序运行结果

3.3 使用异或运算实现数据交换

优势：不需要开辟临时空间

缺点：适用性差（不适用非数值类型)、难以理解和维护

1. 新建源文件DataExchangeWithXorOperator.java

2. 编辑源文件DataExchangeWithXorOperator.java

 package net.ittimeline.java.core.foundational.operator;
    
    /**
     * 数据交换实现方式3：使用异或运算实现数据交换
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/2 20:54
     * @since Java21
     */
    public class DataExchangeWithXorOperator {
        public static void main(String[] args) {
            int left = 10;
            int right = 20;
            System.out.println("数据交换实现方式3：使用异或运算实现数据交换之前");
            System.out.printf("left = %d  right = %d \n", left, right);
            //使用异或运算交换数据
            //优点：不需要开辟临时空间
            //缺点：难以理解和维护  适用性差（不适用非数值类型）
            left = left ^ right;
            System.out.println("1.left ^ right left = " + left);
            right = left ^ right;
            System.out.println("2.left ^ right right = " + right);
            left = left ^ right;
            System.out.println("3.left ^ right left = " + left);
            System.out.println("数据交换实现方式3：使用异或运算实现数据交换之后");
            System.out.printf("left = %d  right = %d \n", left, right);
        }
    }

3. 运行DataExchangeWithXorOperator

程序运行结果