ittimeline

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

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

新建源文件BitAndOperatorPositiveNumberExample1.java

编辑源文件BitAndOperatorPositiveNumberExample1.java

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

/**
 * 按位与运算符操作正整数之 5 & 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitAndOperatorPositiveNumberExample1

程序运行结果

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

新建源文件BitAndOperatorPositiveNumberExample2.java

编辑源文件BitAndOperatorPositiveNumberExample2.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位与运算符操作正整数之 5 & 3
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行BitAndOperatorPositiveNumberExample2

程序运行结果

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

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

新建源文件BitAndOperatorNegativeNumberExample1.java

编辑源文件BitAndOperatorNegativeNumberExample1.java

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

/**
 * 按位与运算符操作负整数之 -5 & -3
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitAndOperatorNegativeNumberExample1

程序运行结果

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

新建源文件BitAndOperatorNegativeNumberExample2.java

编辑源文件BitAndOperatorNegativeNumberExample2.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位与运算符操作负整数之 -5 & -10
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行BitAndOperatorNegativeNumberExample2

程序运行结果

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

新建源文件BitAndOperatorNegativeNumberExample3.java

编辑源文件BitAndOperatorNegativeNumberExample3.java

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

/**
 * 按位与运算符操作负整数之5 & -10
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitAndOperatorNegativeNumberExample3

程序运行结果

1.3 按位或运算符

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

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

新建源文件BitOrOperatorPositiveNumberExample1.java

编辑源文件BitOrOperatorPositiveNumberExample1.java

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

/**
 * 按位或运算符操作正整数之 5 | 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitOrOperatorPositiveNumberExample1

程序运行结果

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

新建源文件BitOrOperatorPositiveNumberExample2.java

编辑源文件BitOrOperatorPositiveNumberExample2.java

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

/**
 * 按位或运算符操作正整数之 5 | 3
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitOrOperatorPositiveNumberExample2

程序运行结果

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

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

新建源文件BitOrOperatorNegativeNumberExample1.java

编辑源文件BitOrOperatorNegativeNumberExample1.java

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

/**
 * 按位或运算符操作负整数之 -5 |-3
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitOrOperatorNegativeNumberExample1

程序运行结果

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

新建源文件BitOrOperatorNegativeNumberExample2.java

编辑源文件BitOrOperatorNegativeNumberExample2.java

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

/**
 * 按位或运算符操作负整数之 -5 |-10
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitOrOperatorNegativeNumberExample2

程序运行结果

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

新建源文件BitOrOperatorNegativeNumberExample3.java

编辑源文件BitOrOperatorNegativeNumberExample3.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位或运算符操作负整数之 5 |-10
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行BitOrOperatorNegativeNumberExample3

程序运行结果

1.4 按位异或运算符

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

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

新建源文件BitXorOperatorPositiveNumberExample1.java

编辑源文件BitXorOperatorPositiveNumberExample1.java

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

/**
 * 按位异或运算符操作正整数之 5 ^ 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitXorOperatorPositiveNumberExample1

程序运行结果

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

新建源文件BitXorOperatorPositiveNumberExample2.java

编辑源文件BitXorOperatorPositiveNumberExample2.java

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

/**
 * 按位异或运算符操作正整数之 5 ^ 3
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitXorOperatorPositiveNumberExample2

程序运行结果

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

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

新建源文件BitXorOperatorNegativeNumberExample1.java

编辑源文件BitXorOperatorNegativeNumberExample1.java

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

/**
 * 按位异或运算符操作负整数之 -5 ^ -3
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitXorOperatorNegativeNumberExample1

程序运行结果

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

新建源文件BitXorOperatorNegativeNumberExample2.java

编辑源文件BitXorOperatorNegativeNumberExample2.java

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

/**
 * 按位异或运算符操作负整数之 -5 ^ -10
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitXorOperatorNegativeNumberExample2

程序运行结果

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

新建源文件BitXorOperatorNegativeNumberExample3.java

编辑源文件BitXorOperatorNegativeNumberExample3.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位异或运算符操作负整数之 5 ^ -10
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行BitXorOperatorNegativeNumberExample3

程序运行结果

1.5 按位取反运算符

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

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

新建源文件BitNotOperatorPositiveNumberExample1.java

编辑源文件BitNotOperatorPositiveNumberExample1.java

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

/**
 * 按位取反运算符操作正整数之~5
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitNotOperatorPositiveNumberExample1

程序运行结果

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

新建源文件BitNotOperatorPositiveNumberExample2.java

编辑源文件BitNotOperatorPositiveNumberExample2.java

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

/**
 * 按位取反运算符操作正整数之~10
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitNotOperatorPositiveNumberExample2

程序运行结果

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

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

新建源文件BitNotOperatorNegativeNumberExample1.java

编辑源文件BitNotOperatorNegativeNumberExample1.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 按位取反运算符操作负整数之~-5
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行BitNotOperatorNegativeNumberExample1

程序运行结果

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

新建源文件BitNotOperatorNegativeNumberExample2.java

编辑源文件BitNotOperatorNegativeNumberExample2

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

/**
 * 按位取反运算符操作负整数之~-10
 *
 * @author tony [email protected]
 * @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));
    }
}

运行BitNotOperatorNegativeNumberExample2

程序运行结果

1.6 左移运算符

1.6.1 左移运算符操作正整数

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

新建源文件LeftShiftBitOperatorPositiveNumberExample1.java

编辑源文件LeftShiftBitOperatorPositiveNumberExample1.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 左移运算符操作正整数之8 << 1
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行LeftShiftBitOperatorPositiveNumberExample1

程序运行结果

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

新建源文件LeftShiftBitOperatorPositiveNumberExample2.java

编辑源文件LeftShiftBitOperatorPositiveNumberExample2.java

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

/**
 * 左移运算符操作正整数之8 << 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行LeftShiftBitOperatorPositiveNumberExample2

程序运行结果

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

新建源文件LeftShiftBitOperatorPositiveNumberExample3.java

编辑源文件LeftShiftBitOperatorPositiveNumberExample3.java

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

/**
 * 左移运算符操作正整数之8 << 28
 *
 * @author tony [email protected]
 * @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));

    }
}

运行LeftShiftBitOperatorPositiveNumberExample3

程序运行结果

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

1.6.2 左移运算符操作负整数

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

新建源文件LeftShiftBitOperatorNegativeNumberExample1.java

编辑源文件LeftShiftBitOperatorNegativeNumberExample1.java

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

/**
 * 左移运算符操作负整数之-8 << 1
 *
 * @author tony [email protected]
 * @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));

    }
}

运行LeftShiftBitOperatorNegativeNumberExample1

程序运行结果

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

新建源文件LeftShiftBitOperatorNegativeNumberExample2.java

编辑源文件LeftShiftBitOperatorNegativeNumberExample2.java

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

/**
 * 左移运算符操作负整数之-8 << 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行LeftShiftBitOperatorNegativeNumberExample2

程序运行结果

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

新建源文件LeftShiftBitOperatorNegativeNumberExample3.java

编辑源文件LeftShiftBitOperatorNegativeNumberExample3.java

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

/**
 * 左移运算符操作负整数之-8 << 28
 *
 * @author tony [email protected]
 * @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));
    }
}

运行LeftShiftBitOperatorNegativeNumberExample3

程序运行结果

1.7 右移运算符

1.7.1 右移运算符操作正整数

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

新建源文件RightShiftBitOperatorPositiveNumberExample1.java

编辑源文件RightShiftBitOperatorPositiveNumberExample1.java

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

/**
 * 右移运算符操作正整数之8 >> 1
 *
 * @author tony [email protected]
 * @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));
    }
}

运行RightShiftBitOperatorPositiveNumberExample1

程序运行结果

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

新建源文件RightShiftBitOperatorPositiveNumberExample2.java

编辑源文件RightShiftBitOperatorPositiveNumberExample2.java

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

/**
 * 右移运算符操作正整数之8 >> 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行RightShiftBitOperatorPositiveNumberExample2

程序运行结果

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

新建源文件RightShiftBitOperatorPositiveNumberExample3.java

编辑源文件RightShiftBitOperatorPositiveNumberExample3.java

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

/**
 * 右移运算符操作正整数之8 >> 4
 *
 * @author tony [email protected]
 * @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));
    }
}

运行RightShiftBitOperatorPositiveNumberExample3

程序运行结果

1.7.2 右移运算符操作负整数

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

新建源文件RightShiftBitOperatorNegativeNumberExample1.java

编辑源文件RightShiftBitOperatorNegativeNumberExample1.java

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

/**
 * 右移运算符操作负整数之-8 >> 1
 *
 * @author tony [email protected]
 * @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));
    }
}

运行RightShiftBitOperatorNegativeNumberExample1

程序运行结果

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

新建源文件RightShiftBitOperatorNegativeNumberExample2.java

编辑源文件RightShiftBitOperatorNegativeNumberExample2.java

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

/**
 * 右移运算符操作负整数之-8 >> 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行RightShiftBitOperatorNegativeNumberExample2

程序运行结果

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

新建源文件RightShiftBitOperatorNegativeNumberExample3.java

编辑源文件RightShiftBitOperatorNegativeNumberExample3.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 右移运算符操作负整数之-8 >> 4
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行RightShiftBitOperatorNegativeNumberExample3

程序运行结果

1.8 无符号右移运算符

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

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

新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample1.java

编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample1.java

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

/**
 * 无符号右移运算符操作正整数之8 >>> 1
 *
 * @author tony [email protected]
 * @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));
    }
}

运行UnsignedRightShiftBitOperatorPositiveNumberExample1

程序运行结果

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

新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java

编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java

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

/**
 * 无符号右移运算符操作正整数之8 >>> 2
 *
 * @author tony [email protected]
 * @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));
    }
}

运行UnsignedRightShiftBitOperatorPositiveNumberExample2

程序运行结果

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

新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java

编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java

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

/**
 * 无符号右移运算符操作正整数之8 >>> 4
 *
 * @author tony [email protected]
 * @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));
    }
}

运行UnsignedRightShiftBitOperatorPositiveNumberExample3

程序运行结果

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

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

新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample1.java

编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample1.java

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

/**
 * 无符号右移运算符操作负整数之-8 >>> 1
 *
 * @author tony [email protected]
 * @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));
    }
}

运行UnsignedRightShiftBitOperatorNegativeNumberExample1

程序运行结果

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

新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java

编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java

 package net.ittimeline.java.core.foundational.operator.bit;
    
    /**
     * 无符号右移运算符操作负整数之-8 >>> 2
     *
     * @author tony [email protected]
     * @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));
        }
    }

运行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 赋值运算符基本使用

新建包

新建源文件AssignmentOperatorUsage.java

编辑源文件AssignmentOperatorUsage.java

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

/**
 * 基本赋值运算符的使用
 *
 * @author tony [email protected]
 * @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));
    }
}

运行AssignmentOperatorUsage

程序运行结果

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

新建源文件ExtendsAssignmentOperatorUsage.java

编辑源文件ExtendsAssignmentOperatorUsage.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 扩展赋值运算符使用
     *
     * @author tony [email protected]
     * @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);
    
        }
    }

运行ExtendsAssignmentOperatorUsage

程序运行结果

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

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

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

新建源文件AssignmentOperatorWarning1.java

编辑源文件AssignmentOperatorWarning1.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 赋值运算符注意事项1
     *
     * @author tony [email protected]
     * @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);
        }
    }

运行AssignmentOperatorWarning1

程序运行结果

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

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

新建源文件AssignmentOperatorWarning2.java

编辑源文件AssignmentOperatorWarning2.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 赋值运算符注意事项2
     *
     * @author tony [email protected]
     * @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);
        }
    }

运行AssignmentOperatorWarning2

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

程序运行结果

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

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

新建源文件AssignmentOperatorWarning3.java

编辑源文件AssignmentOperatorWarning3.java

 package net.ittimeline.java.core.foundational.operator.assignment;
    
    /**
     * 赋值运算符使用注意事项3
     *
     * @author tony [email protected]
     * @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);
        }
    }

运行AssignmentOperatorWarning3

程序运行结果

2.4 赋值运算符案例

2.4.1 实现变量值加1

新建源文件AssignmentOperatorExample1.java

编辑源文件AssignmentOperatorExample1.java

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

/**
 * 算术运算符案例1：实现变量值加1
 *
 * @author tony [email protected]
 * @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);
    }
}

运行AssignmentOperatorExample1

程序运行结果

2.4.2 实现变量值加2

新建源文件AssignmentOperatorExample2.java

编辑源文件AssignmentOperatorExample2.java

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

/**
 * 赋值运算符案例2：实现变量值加2
 *
 * @author tony [email protected]
 * @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);
    }
}

运行AssignmentOperatorExample2

程序运行结果

3. 三种数据交换的方式

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

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

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

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

缺点：需要开辟临时空间

新建源文件DataExchangeWithTemp.java

编辑源文件DataExchangeWithTemp.java

   package net.ittimeline.java.core.foundational.operator;
    
    /**
     * 数据交换实现方式1：使用临时变量实现数据交换
     *
     * @author tony [email protected]
     * @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);
        }
    }

运行DataExchangeWithTemp

程序运行结果

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

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

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

新建源文件DataExchangeWithArithmeticOperator.java

编辑源文件DataExchangeWithArithmeticOperator.java

 package net.ittimeline.java.core.foundational.operator;
    
    /**
     * 数据交换实现方式2：使用算术运算实现数据交换
     *
     * @author tony [email protected]
     * @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);
        }
    }

运行DataExchangeWithArithmeticOperator

程序运行结果

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

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

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

新建源文件DataExchangeWithXorOperator.java

编辑源文件DataExchangeWithXorOperator.java

 package net.ittimeline.java.core.foundational.operator;
    
    /**
     * 数据交换实现方式3：使用异或运算实现数据交换
     *
     * @author tony [email protected]
     * @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);
        }
    }

运行DataExchangeWithXorOperator

程序运行结果

你可能感兴趣的:(180天Java从小白到就业,#,java,python,开发语言,算法,面试,程序人生)

【Python】一文详细介绍 py格式文件高斯小哥 Python基础【高质量合集】python 新手入门学习
【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
亲子日记之祝姑姥姥生日快乐（282）冰心雨露_d504
2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
100天30本书读书计划（2018-06-11）DAY 62 一个姜姜
【书名】当我谈跑步时，我谈些什么【作者】村上春树【读书页数】51--128/187【读书时间】2018年6月11日【精彩句子】01肌肉难长，易消。赘肉易长，难消。P5502肌肉也同有血有肉的动物一般无二，它也愿意过更舒服的日子，不继续给它负荷，它便会心安理得地将记忆出去。想再度输入的话，必须得从头开始，将同样的模式重复一遍。P7703不管怎样，反正得坚持跑步。每天跑步对我来说好比生命线，不能说忙就
植物小记番茄秧子
小时候，我养过一院子的花。今年，我重新开始从头开始养一点儿植物。别人说那也只是别人说临到快过年，我逛了一趟花市，买了两棵水仙花。路过另外一个卖水仙的摊位，霸气的卖花小妹瞧了一眼我捧着的那两棵弱小，说了一句：“你那个水仙不行，都不会开花的。”以我的脾气，这当然不能相信啊。结果，带回家好几天没动静。某一天早晨起来，两棵水仙悄不吭声全开了，然后香了屋子好多天。水仙三月，我在花市扛了一盆栀子花，花店老板见
数据结构奇妙旅程之深入解析快速排序山间漫步人生路数据结构排序算法算法
快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
被隔离的日子（五）@三七会写作营三七会萍海临风
从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
python抓包与解包_Python—网络抓包与解包（pcap、dpkt） weixin_39691055 python抓包与解包
pcap安装[root@localhost~]#pipinstallpypcap抓包与解包#-*-coding:utf-8-*-importpcap,dpktimportre,threading,requests__black_ip=['103.224.249.123','203.66.1.212']#抓包：param1eth_name网卡名，如：eth0,eth3。param2p_type日志捕
通俗易懂：MySQL中如何设置只读实例并确保数据一致性？大龄下岗程序员 mysql java mysql spring
在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication
生活中的鸡毛蒜皮-----心情琐碎记录安家妈妈
陪孩子打预防针回来时的小发现今天天气特别的好，阳光灿烂，太阳晒得人暖融融的。可惜这么好的天气就不去郊游，而是去打预防针疫苗。孩子已经六岁了，这是最后的一次接种疫苗打针。昨天晚上接到电话，还有一点担心孩子会害怕，会不会紧张，来医院会不会怕到不敢进去。试想哪一个孩子听到打针会不紧张呢？结果过程居然顺利的不可思议，没有紧张也没有害怕，也没有反复的问。来到社区医院的大楼，还觉得非常有趣好玩的样子。为了让她
易经第六十一卦风泽中孚徐徐微风正好
易经第六十一卦风泽中孚，巽上兑下。中孚：豚鱼吉，利涉大川，利贞。中孚卦象征着中心诚信，甚至诚信到了能够感动小猪小鱼，可获吉祥，对渡过大河巨流有利，对坚守正道有利。诚信是立人之本，立身处世心怀诚信广施仁义才会走的长远。但是诚信也要合理合时，君子从中得到启示，要以诚信的德行慎重审议案件并宽缓死刑。诚信可以使人信服，有利于坚守中正，内在谦逊柔顺外在坚守行动诚信，连最顽固的老百姓都被感化，天何言哉，四时行
下载Android源码赛非斯
repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
读思001 ‖ 变负能为正能，变压力为动力你不懂夜的黑
今天起开始写一个言说文集连载，重点为读写思考收获和感想，也收录生活和工作中开悟到的点滴，仍然是一个碎片式的思考积累。希望这样的思考能启迪我的生活智慧，开悟我的思想境界，也算是一个修心的过程吧。这个连载不定期更新，重在积累生活和工作中的随思碎思，或许也是一厢情愿的一个梦。也或许这个梦是我坚持说下去的一个重要理由。读思001变负能为正能，变压力为动力1从来没有一种哲学能解决一切问题，也从来没有一种药能
新网师的精神肤色（幕布笔记）悦读书香
王子老师的《极简100小妙招》收到已经几天了，之前大概的浏览了全书，今天起给自己定了一个计划，必须每天学习极简小妙招里面的一个妙招，并加以运用。一、今天要打卡什么内容因有完成每天学习极简小妙招的计划，所以今天晚饭吃的比较简单，草草吃完以后带着小宝到广场溜达一圈，急忙赶回来学习极简小妙招。再重看的时候不知道自己要学点什么，打卡哪一招，感觉哪个都简单，就看这一环节像王子老师说的“一看就会”，但做这一环
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
《对我而言危险的他》：“假千金”归来，携手神秘霸总共破迷局入骨影评
由樊治欣李墨之主演的都市悬疑爱情剧《对我而言危险的他》在网上平台一次性播出全集。虽然是个小成本网剧，呈现出来的效果却十分有诚意。剧中从车祸到坠海、再到徒手灭火等惊险场面都是实景拍摄和主演们的无替身上场。说起樊治欣这个名字可能大家都不熟悉，但提起他演过的剧，大家都不陌生。饰演过《暗格里的秘密》中的学长苏柏从的樊治欣在这部剧中饰演霸总严星呈，即便同样戴着眼镜，却给人不一样的观感。该剧主要讲述了女主沈漫
男人请珍惜十六七岁陪在你身边的女孩吧小朋友嘿哈
你相信那种从校服到婚纱的爱情吗。01朋友阿伟18岁的时候就是一混混，放学不是和这个学校的学生约架，就是那个小弟被欺负了要为此出头，溜冰场上看谁不顺眼，一个字：打。当然，放学蹲点泡妞是常事，看到这个学生妹浓妆艳抹，搭讪，看到那个前凸后翘的，搭讪。阿伟也不例外，他说：“我当时和几个兄弟在学校后门的小卖部抽烟，姗姗背着双肩背包，扎着马尾辫，看到我们几个混混有些害怕的低着头快步走过我们面前，那时候我在想啊
php 把一个数组分成有n个元素的二维数组的算法风清扬-独孤九剑 php php 算法
一、第一种解法0){$columns_map[$position]++;//这个地方格外注意,$position与$columns比较$position=($position<$columns-1)?++$position:0;$array_length--;}foreach($columns_mapas$val){$newarray[]=array_splice($array,0,$val);}
学习JavaEE的日子 Day32 线程池 A 北枝学习JavaEE 学习 java-ee java 线程池
Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
你之所以胖，可能是因为小时候发生这件事！还不赶快甩锅周围_5d19
通常，我们认为，“肥胖”主要是由于饮食不节制、不经常运动等等因素引起的。但最近，我国学者开展的一项针对6到18岁儿童青少年、随访长达十年的代谢综合征研究结果，在权威国际期刊发表。研究发现，儿童的肥胖和超重与睡眠密切相关，儿童、青少年时期睡眠不好，成人后也更容易患心血管疾病。那么，为什么儿童青少年睡眠不足会导致肥胖呢？今天就带大家一探究竟。儿童青少年肥胖的现状如何？近日，一项刊载在医学权威期刊《柳叶
淘宝天猫38节活动时间和玩法，2024年焕新周满减优惠多少小小编007
在2024年，淘宝天猫平台即将迎来一年一度的38节活动，这是广大消费者们翘首以待的购物狂欢节。在这篇文章中，我们将为您详细解读淘宝天猫38节活动的时间安排和玩法，以及2024年焕新周的满减优惠力度。一、淘宝天猫38节活动时间2024年淘宝天猫38节活动将于2月28日正式启动，持续至3月8日，为期10天。活动期间，消费者们可以尽情享受各种优惠折扣、满减活动以及限时秒杀，尽情释放购物热情。2024淘宝
❤️ 美娟感恩福记 32/365 让一切都成为你的助力
感恩信守承诺完成✅的一天感恩连睡梦中都惦记着“感恩”，夜晚睡的香甜，好感恩，谢谢感恩好手艺，营养早餐，开启了美好的一天感恩感恩健身，让自己的身体肌肉变得结实，painisweaknessleavingthebody!痛苦会让软弱离开身体！好棒的，渐渐爱上燃烧脂肪的感觉，喜欢精气神饱满的自己感恩感恩奶奶的夸赞，把堉哥哥买给奶奶的蚕丝被邮寄回去了，奶奶很高兴，有人惦记着她，也是因为奶奶智慧的规劝，才遇
python 推导式(派生、衍生) sanduo112 人工智能 python windows 开发语言
python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
所有的突然想起，都是一直放在心里清浅白芷
一天，看到朋友圈发了一张木林的图片，熟悉而又陌生，心里怔住了一下，突然想起他以及往事。想起那年我们在旅途认识，而后又因旅途分开的故事。点点滴滴，在脑海里盘旋，在回忆里辗转。还记得相遇的那天，因为他的幽默风趣，把全场疲惫不堪的人逗笑了，他笑起来的样子不是很好看，但感觉很舒服。后来我们通过在网上联系，加深了对彼此的了解，便互生情愫，然后恋爱。只是后来，经过一年多的相处，我们就分开了。虽然时间很短，但仿
为什么说仪式和习惯非常重要？章鱼老师zy
这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
为自己点滴的进步喝彩 e5633888b9f4
当听到单位需要每周一三五加班到九点的时候，内心很坦然，没有指责抱怨，想到的是：又体验一下值夜班的感觉，还能趁此机会多与大家待在一起，孩子也可以得到独立方面的锻炼，一切都不是问题，搞不好再发点加班费就更好了，把这些都看成多得的，心情美美的，自己的事全力以赴做好，别人的事选择尊重，老天的事选择臣服。只要心有了目标，方向正确，就不怕路途的遥远。我们每一个人都不是孤立存在的，祖先一代代传承将生命体传承给了
【算法分析与设计】去除重复字母五敷有你算法分析与设计 java javascript 开发语言算法数据结构
个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
第一章山洞传来牛铃声满眼荷花
春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
12-25 yummy0632
72.4kg早饭：一碗面条，俩鸡蛋，三个砂糖桔。五天过去了，这本书我听完了。哈哈简直了。真兴奋，我准备好了，迎接新的自己。午饭：一个花卷，一碗汤，一份油菜，一份冬瓜粉条，一份红烧肉。晚饭：一个花卷，一份芹菜，一份土豆，一份鸭子。很咸。
有一种失去叫做得不到野风狂生
图片发自App有一种失去叫做得不到野风狂生（20190130）有一种失去叫做得不到失去的是希望是前进的方向是奋斗的动力是奇迹的召唤纵然有一天将其释怀遗憾的残迹却永留心底得不到有时也会心痛仿佛沙漠里远望着的一泓甘泉十米处被他人喝干涸仿佛黑洞里疲惫追逐的火焰在握住前一秒耗尽光明仿佛风雪彻骨的冬天被人剥剩至赤裸而夜行山莽埋葬未曾示面的野心有谁还会去祭奠不用问我问我也无可奉告不用问你问你也缄默不言去拥抱那
数据挖掘|数据预处理|基于Python的数据标准化方法皖山文武数据挖掘数据建模与分析 python 数据挖掘开发语言
基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
统一思想认识永夜-极光思想
1.统一思想认识的基础,才能有的放矢原因: 总有一种描述事物的方式最贴近本质,最容易让人理解. 如何让教育更轻松,在于找到最适合学生的方式. 难点在于,如何模拟对方的思维基础选择合适的方式. &
Joda Time使用笔记 bylijinnan java joda time
Joda Time的介绍可以参考这篇文章： http://www.ibm.com/developerworks/cn/java/j-jodatime.html 工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法： /** * DateTime变化（增减） */ @Tes
FileUtils API eksliang FileUtils FileUtils API
转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。非常的好用。
各种新兴技术不懂事的小屁孩技术
1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。现在构建系统常用到maven工具，现在有更容易上手的gradle，搭建java环境: http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 搭建android环境： http://m
tomcat6的https双向认证酷的飞上天空 tomcat6
1.生成服务器端证书 keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
托管虚拟桌面市场势不可挡蓝儿唯美
用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 MSP的利润空间将根据其参与的程度而有所不同，Din说。 “我们有一些合作伙伴负责将我们推荐给客户作为个
spring学习——xml文件的配置 a-john spring
在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or
HDU 4342 History repeat itself 模拟 aijuans 模拟
来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
java中最常用jar包的用途 asia007 java
java中最常用jar包的用途 jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法. w
ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法百合不是茶 js json编码返回异常
一:ajax获取自定义Struts框架中的json编码出现以下问题: 1,强制flush输出 json编码打印在首页 2, 不强制flush js会解析json 打印出来的是错误的jsp页面却没有跳转到错误页面 3, ajax中的dataType的json 改为text 会
JUnit使用的设计模式 bijian1013 java 设计模式 JUnit
JUnit源代码涉及使用了大量设计模式 1、模板方法模式（Template Method）定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。
Linux常用命令（摘录） sunjing crond chkconfig
chkconfig --list 查看linux所有服务 chkconfig --add servicename 添加linux服务 netstat -apn | grep 8080 查看端口占用 env 查看所有环境变量 echo $JAVA_HOME 查看JAVA_HOME环境变量安装编译器 yum install -y gcc
【Hadoop一】Hadoop伪集群环境搭建 bit1129 hadoop
结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。 &nb
Anychart图表系列五之事件监听白糖_ chart
创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： <script> //创建AnyChart var chart = new AnyChart(); //添加钻取操作&quo
Web前端相关段子 braveCS web前端
Web标准：结构、样式和行为分离使用语义化标签 0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
编程之美-24点游戏 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.Set; public class PointGame { /**编程之美
主页面子页面传值总结 chengxuyuancsdn 总结
1、showModalDialog returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值主界面 var sonValue=window.showModalDialog("son.jsp"); 子界面 window.retu
[网络与经济]互联网+的含义 comsci 互联网+
互联网+后面是一个人的名字 = 网络控制系统互联网+你的名字 = 网络个人数据库每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
oracle 创建视图 with check option daizj 视图 view oralce
我们来看下面的例子： create or replace view testview as select empno,ename from emp where ename like ‘M%’ with check option; 这里我们创建了一个视图，并使用了with check option来限制了视图。然后我们来看一下视图包含的结果： select * from testv
ToastPlugin插件在cordova3.3下使用 dibov Cordova
自己开发的Todos应用，想实现“ 再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。 ToastPlugin.java package&nbs
C语言22个系统函数 dcj3sjt126com c function
C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
开发一个类的流程 dcj3sjt126com 开发
本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。以下是开发流程： 1. 明确类的功能，抽象出类的大概结构 2. 初步设想类的接口 3. 类名设计（驼峰式命名） 4. 属性设置(权限设置) 判断某些变量是否有必要作为成员属
java 并发 shuizhaosi888 java 并发
能够写出高伸缩性的并发是一门艺术在JAVA SE5中新增了3个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks 在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。
Spring Security（11）——匿名认证 234390216 Spring Security ROLE_ANNOYMOUS 匿名
匿名认证目录 1.1 配置 1.2 AuthenticationTrustResolver 对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
NODEJS项目实践0.2[ express,ajax通信...] 逐行分析JS源代码 Ajax nodejs express
一、前言通过上节学习，我们已经 ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务及 mongodb的存取，但写着写着，web端就
在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值 lhbthanks java html struts checkbox
第一种方法：获取结果String类型在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。以下是实现的代码：前台 HTML 代码：
003.Kafka基本概念 nweiren hadoop kafka
Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。 Topic：消息源（Message）的分类。 Partition： Topic物理上的分组，一
Linux环境下安装JDK roadrunners jdk linux
1、准备工作创建JDK的安装目录： mkdir -p /usr/java/ 下载JDK，找到适合自己系统的JDK版本进行下载： http://www.oracle.com/technetwork/java/javase/downloads/index.html 把JDK安装包下载到/usr/java/目录，然后进行解压： tar -zxvf jre-7
Linux忘记root密码的解决思路 tomcat_oracle linux
1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断. 　　3: grub启动菜单中加入 single以单用户进入系统. 　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除　　例如: 　　ro
跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现 xueyou jsonp jquery 框架 UI html5
postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p