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

Java位运算符、赋值运算符、三种数据交换的方式

1. 位运算符

Q：为什么要学习位运算

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

HashMap

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

image

  1. 新建源文件BitAndOperatorPositiveNumberExample1.java

image

  1. 编辑源文件BitAndOperatorPositiveNumberExample1.java

image

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 01012的补码：0000 0000 0000 0000 0000 0000 0000 00102.计算5 & 2按位与计算规则是按照二进制位进行与运算：同1为1，有0为00000 0000 0000 0000 0000 0000 0000 0101&0000 0000 0000 0000 0000 0000 0000 0010=0000 0000 0000 0000 0000 0000 0000 00003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0000的原码是0000 0000 0000 0000 0000 0000 0000 00004.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0000转换为十进制结果是05. 最终结果就是5 & 2 = 0*/System.out.println("5 & 2 = " + (5 & 2));}
}
  1. 运行BitAndOperatorPositiveNumberExample1

image

程序运行结果

image

1.2.1.2 按位与运算符操作正整数之5 & 3
  1. 新建源文件BitAndOperatorPositiveNumberExample2.java

image

  1. 编辑源文件BitAndOperatorPositiveNumberExample2.java

image

 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 01013的补码：0000 0000 0000 0000 0000 0000 0000 00112.计算5 & 3按位与计算规则是按照二进制位进行与运算：同1为1，有0为00000 0000 0000 0000 0000 0000 0000 0101&0000 0000 0000 0000 0000 0000 0000 0011=0000 0000 0000 0000 0000 0000 0000 00013.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0001的原码是0000 0000 0000 0000 0000 0000 0000 00014.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是15. 最终结果就是5 & 3 = 1*/System.out.println("5 & 3 = " + (5 & 3));}}
  1. 运行BitAndOperatorPositiveNumberExample2

image

程序运行结果

image

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

1.2.2.1 按位与运算符操作负整数之 -5 & -3
  1. 新建源文件BitAndOperatorNegativeNumberExample1.java

image

  1. 编辑源文件BitAndOperatorNegativeNumberExample1.java

image

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 01013的原码：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 11012.计算-5 & -3按位与计算规则是按照二进制位进行与运算：同1为1，有0为01111 1111 1111 1111 1111 1111 1111 1011&1111 1111 1111 1111 1111 1111 1111 1101=1111 1111 1111 1111 1111 1111 1111 10013.将补码换算成原码（根据补码求原码）①根据补码求反码：补码-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 01114.将原码转换为十进制（ 打印输出结果是十进制）1000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是-75. 最终结果就是-5 & -3 = -7*/System.out.println("-5 & -3 = " + (-5 & -3));}
}
  1. 运行BitAndOperatorNegativeNumberExample1

image

程序运行结果

image

1.2.2.2 按位与运算符操作负整数之 -5 & -10
  1. 新建源文件BitAndOperatorNegativeNumberExample2.java

image

  1. 编辑源文件BitAndOperatorNegativeNumberExample2.java

image

 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 010110的原码：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 01102.计算-5 & -10按位与计算规则是按照二进制位进行与运算：同1为1，有0为01111 1111 1111 1111 1111 1111 1111 1011&1111 1111 1111 1111 1111 1111 1111 0110=1111 1111 1111 1111 1111 1111 1111 00103.将补码换算成原码（根据补码求原码）①根据补码求反码：补码-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 11104.将原码转换为十进制（ 打印输出结果是十进制）1000 0000 0000 0000 0000 0000 0000 1110转换为十进制结果是-145. 最终结果就是-5 & -10 = -14*/System.out.println("-5 & -10 = " + (-5 & -10));}}
  1. 运行BitAndOperatorNegativeNumberExample2

image

程序运行结果

image

1.2.2.3 按位与运算符操作负整数之5 & -10
  1. 新建源文件BitAndOperatorNegativeNumberExample3.java

image

  1. 编辑源文件BitAndOperatorNegativeNumberExample3.java

image

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 010110的原码：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 01102.计算5 & -10按位与计算规则是按照二进制位进行与运算：同1为1，有0为00000 0000 0000 0000 0000 0000 0000 0101&1111 1111 1111 1111 1111 1111 1111 0110=0000 0000 0000 0000 0000 0000 0000 01003.将补码换算成原码补码0000 0000 0000 0000 0000 0000 0000 0100转换成原码是0000 0000 0000 0000 0000 0000 0000 01004.将原码转换为十进制（ 打印输出结果是十进制）0000 0000 0000 0000 0000 0000 0000 0100转换为十进制结果是45. 最终结果就是5 & -10 = 4*/System.out.println("5 & -10 = " + (5 & -10));}
}
  1. 运行BitAndOperatorNegativeNumberExample3

image

程序运行结果

image

1.3 按位或运算符

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

1.3.1.1 按位或运算符操作正整数之 5 | 2
  1. 新建源文件BitOrOperatorPositiveNumberExample1.java

image

  1. 编辑源文件BitOrOperatorPositiveNumberExample1.java

image

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 01012的补码：0000 0000 0000 0000 0000 0000 0000 00102.计算5 | 2按位或计算规则是按照二进制位进行或运算：有1为1，同0为00000 0000 0000 0000 0000 0000 0000 0101|0000 0000 0000 0000 0000 0000 0000 0010=0000 0000 0000 0000 0000 0000 0000 01113.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0111的原码是0000 0000 0000 0000 0000 0000 0000 01114.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是75. 最终结果就是5 | 2 = 7*/System.out.println("5 | 2 = " + (5 | 2));}
}
  1. 运行BitOrOperatorPositiveNumberExample1

image

程序运行结果

image

1.3.1.2 按位或运算符操作正整数之 5 | 3
  1. 新建源文件BitOrOperatorPositiveNumberExample2.java

image

  1. 编辑源文件BitOrOperatorPositiveNumberExample2.java

image

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 01013的补码：0000 0000 0000 0000 0000 0000 0000 00112.计算5 | 3按位或计算规则是按照二进制位进行或运算：有1为1，同0为00000 0000 0000 0000 0000 0000 0000 0101|0000 0000 0000 0000 0000 0000 0000 0011=0000 0000 0000 0000 0000 0000 0000 01113.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0111的原码是0000 0000 0000 0000 0000 0000 0000 01114.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是75. 最终结果就是5 | 3 = 7*/System.out.println("5 | 3 = " + (5 | 3));}
}
  1. 运行BitOrOperatorPositiveNumberExample2

image

程序运行结果

image

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

1.3.2.1 按位或运算符操作负整数之 -5 |-3
  1. 新建源文件BitOrOperatorNegativeNumberExample1.java

image

  1. 编辑源文件BitOrOperatorNegativeNumberExample1.java

image

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 01013的原码：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 11012.计算-5 | -3按位或计算规则是按照二进制位进行或运算：有1为1，同0为01111 1111 1111 1111 1111 1111 1111 1011|1111 1111 1111 1111 1111 1111 1111 1101=1111 1111 1111 1111 1111 1111 1111 11113.将补码换算成原码（根据补码求原码）①根据补码求反码：补码-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 00014.将原码转换为十进制（ 打印输出结果是十进制）1000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是-15. 最终结果就是-5 | -3 = -1*/System.out.println("-5 | -3 = " + (-5 | -3));}
}
  1. 运行BitOrOperatorNegativeNumberExample1

image

程序运行结果

image

1.3.2.2 按位或运算符操作负整数之 -5 |-10
  1. 新建源文件BitOrOperatorNegativeNumberExample2.java

image

  1. 编辑源文件BitOrOperatorNegativeNumberExample2.java

image

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 010110的原码：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 01102.计算-5 | -10按位或计算规则是按照二进制位进行或运算：有1为1，同0为01111 1111 1111 1111 1111 1111 1111 1011|1111 1111 1111 1111 1111 1111 1111 0110=1111 1111 1111 1111 1111 1111 1111 11113.将补码换算成原码（根据补码求原码）①根据补码求反码：补码-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 00014.将原码转换为十进制（ 打印输出结果是十进制）1000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是-15. 最终结果就是-5 | -10 = -1*/System.out.println("-5 | -10 = " + (-5 | -10));}
}
  1. 运行BitOrOperatorNegativeNumberExample2

image

程序运行结果

image

1.3.2.3 按位或运算操作负整数之 5 |-10
  1. 新建源文件BitOrOperatorNegativeNumberExample3.java

image

  1. 编辑源文件BitOrOperatorNegativeNumberExample3.java

image

 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 010110的原码：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 01102.计算5 | -10按位或计算规则是按照二进制位进行或运算：有1为1，同0为00000 0000 0000 0000 0000 0000 0000 0101|1111 1111 1111 1111 1111 1111 1111 0110=1111 1111 1111 1111 1111 1111 1111 01113.将补码换算成原码①根据补码求反码：反码=补码-11111 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 10014.将原码转换为十进制（ 打印输出结果是十进制）1000 0000 0000 0000 0000 0000 0000 1001转换为十进制结果是-95. 最终结果就是5 | -10 = -9*/System.out.println("5 | -10 = " + (5 | -10));}}
  1. 运行BitOrOperatorNegativeNumberExample3

image

程序运行结果

image

1.4 按位异或运算符

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

1.4.1.1 按位异或运算符操作正整数之 5 ^ 2
  1. 新建源文件BitXorOperatorPositiveNumberExample1.java

image

  1. 编辑源文件BitXorOperatorPositiveNumberExample1.java

image

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 01012的补码：0000 0000 0000 0000 0000 0000 0000 00102.计算5 ^ 2按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为10000 0000 0000 0000 0000 0000 0000 0101^0000 0000 0000 0000 0000 0000 0000 0010=0000 0000 0000 0000 0000 0000 0000 01113.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0111的原码是0000 0000 0000 0000 0000 0000 0000 01114.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0111转换为十进制结果是75. 最终结果就是5 ^ 2 = 7*/System.out.println("5 ^ 2 = " + (5 ^ 2));}
}
  1. 运行BitXorOperatorPositiveNumberExample1

image

程序运行结果

image

1.4.1.2 按位异或运算符操作正整数之 5 ^ 3
  1. 新建源文件BitXorOperatorPositiveNumberExample2.java

image

  1. 编辑源文件BitXorOperatorPositiveNumberExample2.java

image

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 01013的补码：0000 0000 0000 0000 0000 0000 0000 00112.计算5 ^ 3按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为10000 0000 0000 0000 0000 0000 0000 0101^0000 0000 0000 0000 0000 0000 0000 0011=0000 0000 0000 0000 0000 0000 0000 01103.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0110的原码是0000 0000 0000 0000 0000 0000 0000 01104.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是65. 最终结果就是5 ^ 3 = 6*/System.out.println("5 ^ 3 = " + (5 ^ 3));}
}
  1. 运行BitXorOperatorPositiveNumberExample2

image

程序运行结果

image

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

1.4.2.1 按位异或运算符操作负整数之 -5 ^ -3
  1. 新建源文件BitXorOperatorNegativeNumberExample1.java

image

  1. 编辑源文件BitXorOperatorNegativeNumberExample1.java

image

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 01013的原码：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 11012.计算-5 ^ -3按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为11111 1111 1111 1111 1111 1111 1111 1011^1111 1111 1111 1111 1111 1111 1111 1101=0000 0000 0000 0000 0000 0000 0000 01103.将补码换算成原码（根据补码求原码）补码0000 0000 0000 0000 0000 0000 0000 0110的原码是0000 0000 0000 0000 0000 0000 0000 01104.将原码转换为十进制（ 打印输出结果是十进制）0000 0000 0000 0000 0000 0000 0000 0110转换为十进制结果是65. 最终结果就是-5 ^ -3 = 6*/System.out.println("-5 ^ -3 = " + (-5 ^ -3));}
}
  1. 运行BitXorOperatorNegativeNumberExample1

image

程序运行结果

image

1.4.2.2 按位异或运算符操作负整数之 -5 ^ -10
  1. 新建源文件BitXorOperatorNegativeNumberExample2.java

image

  1. 编辑源文件BitXorOperatorNegativeNumberExample2.java

image

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 010110的原码：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 01102.计算-5 ^ -10按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为11111 1111 1111 1111 1111 1111 1111 1011^1111 1111 1111 1111 1111 1111 1111 0110=0000 0000 0000 0000 0000 0000 0000 11013.将补码换算成原码（根据补码求原码）补码0000 0000 0000 0000 0000 0000 0000 1101转换为原码是0000 0000 0000 0000 0000 0000 0000 11014.将原码转换为十进制（ 打印输出结果是十进制）0000 0000 0000 0000 0000 0000 0000 1101转换为十进制结果是135. 最终结果就是-5 ^ -10 = 13*/System.out.println("-5 ^ -10 = " + (-5 ^ -10));}
}
  1. 运行BitXorOperatorNegativeNumberExample2

image

程序运行结果

image

1.4.2.3 按位异或运算符操作负整数之 5 ^ -10
  1. 新建源文件BitXorOperatorNegativeNumberExample3.java

image

  1. 编辑源文件BitXorOperatorNegativeNumberExample3.java

image

 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 010110的原码：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 01102.计算5 ^ -10按位异或计算规则是按照二进制位进行异或运算：相同为0，不同为10000 0000 0000 0000 0000 0000 0000 0101^1111 1111 1111 1111 1111 1111 1111 0110=1111 1111 1111 1111 1111 1111 1111 00113.将补码换算成原码①根据补码求反码：反码=补码-11111 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 11014.将原码转换为十进制（ 打印输出结果是十进制）1000 0000 0000 0000 0000 0000 0000 1101转换为十进制结果是-135. 最终结果就是5 ^ -10 = -13*/System.out.println("5 ^ -10 = " + (5 ^ -10));}}
  1. 运行BitXorOperatorNegativeNumberExample3

image

程序运行结果

image

1.5 按位取反运算符

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

1.5.1.1 按位取反运算符操作正整数之~5
  1. 新建源文件BitNotOperatorPositiveNumberExample1.java

image

  1. 编辑源文件BitNotOperatorPositiveNumberExample1.java

image

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 01012.计算~5按位与计算规则是按照二进制位取反：1为0，0为10000 0000 0000 0000 0000 0000 0000 0101~=1111 1111 1111 1111 1111 1111 1111 10103.将补码换算成原码查看运算结果看原码,负数的原码是补码减1取反①根据补码求反码：反码=补码减11111 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 01104.将原码转换为十进制打印输出结果是十进制1000 0000 0000 0000 0000 0000 0000 0110转换为十进制结果是-65. 最终结果就是~5 = -6*/System.out.println("~5 = " + (~5));}
}
  1. 运行BitNotOperatorPositiveNumberExample1

image

程序运行结果

image

1.5.1.2 按位取反运算符操作正整数之~10
  1. 新建源文件BitNotOperatorPositiveNumberExample2.java

image

  1. 编辑源文件BitNotOperatorPositiveNumberExample2.java

image

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 10102.计算~10按位与计算规则是按照二进制位取反：1为0，0为10000 0000 0000 0000 0000 0000 0000 1010~=1111 1111 1111 1111 1111 1111 1111 01013.将补码换算成原码查看运算结果看原码,负数的原码是补码减1取反①根据补码求反码：反码=补码减11111 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 10114.将原码转换为十进制打印输出结果是十进制1000 0000 0000 0000 0000 0000 0000 1011转换为十进制结果是-115. 最终结果就是~10 = -11*/System.out.println("~10 = " + (~10));}
}
  1. 运行BitNotOperatorPositiveNumberExample2

image

程序运行结果

image

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

1.5.2.1 按位取反运算符操作负整数之 ~-5
  1. 新建源文件BitNotOperatorNegativeNumberExample1.java

image

  1. 编辑源文件BitNotOperatorNegativeNumberExample1.java

image

 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 10112.计算~-5按位与计算规则是按照二进制位取反：1为0，0为11111 1111 1111 1111 1111 1111 1111 1011~=0000 0000 0000 0000 0000 0000 0000 01003.将补码换算成原码（根据补码求原码）补码0000 0000 0000 0000 0000 0000 0000 0100转换成原码是0000 0000 0000 0000 0000 0000 0000 01004.将原码转换为十进制（ 打印输出结果是十进制）0000 0000 0000 0000 0000 0000 0000 0100转换为十进制结果是45. 最终结果就是~-5 = 4*/System.out.println("~-5 = " + (~-5));}}
  1. 运行BitNotOperatorNegativeNumberExample1

image

程序运行结果

image

1.5.2.2 按位取反运算符操作负整数之~-10
  1. 新建源文件BitNotOperatorNegativeNumberExample2.java

image

  1. 编辑源文件BitNotOperatorNegativeNumberExample2

image

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 01102.计算~-10按位与计算规则是按照二进制位取反：1为0，0为11111 1111 1111 1111 1111 1111 1111 0110~=0000 0000 0000 0000 0000 0000 0000 10013.将补码换算成原码（根据补码求原码）补码0000 0000 0000 0000 0000 0000 0000 1001转换成原码是0000 0000 0000 0000 0000 0000 0000 10014.将原码转换为十进制（ 打印输出结果是十进制）0000 0000 0000 0000 0000 0000 0000 1001转换为十进制结果是95. 最终结果就是~-10 = 9*/System.out.println("~-10 = " + (~-10));}
}
  1. 运行BitNotOperatorNegativeNumberExample2

image

程序运行结果

image

1.6 左移运算符

1.6.1 左移运算符操作正整数

1.6.1.1 左移运算符操作正整数之8 << 1
  1. 新建源文件LeftShiftBitOperatorPositiveNumberExample1.java

image

  1. 编辑源文件LeftShiftBitOperatorPositiveNumberExample1.java

image

 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 10002.计算8 << 1左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方0000 0000 0000 0000 0000 0000 0000 1000<< 1=000 0000 0000 0000 0000 0000 0000 100003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码000 0000 0000 0000 0000 0000 0000 10000转换为原码是000 0000 0000 0000 0000 0000 0000 100004.将原码转换为十进制打印输出结果是十进制000 0000 0000 0000 0000 0000 0000 10000转换为十进制结果是165. 最终结果就是8 << 1 = 16*/System.out.println("8 << 1 = " + (8 << 1));}}
  1. 运行LeftShiftBitOperatorPositiveNumberExample1

image

程序运行结果

image

1.6.1.2 左移运算符操作正整数之8 << 2
  1. 新建源文件LeftShiftBitOperatorPositiveNumberExample2.java

image

  1. 编辑源文件LeftShiftBitOperatorPositiveNumberExample2.java

image

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 10002.计算8 << 2左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方0000 0000 0000 0000 0000 0000 0000 1000<< 2=00 0000 0000 0000 0000 0000 0000 1000003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码00 0000 0000 0000 0000 0000 0000 100000转换为原码是00 0000 0000 0000 0000 0000 0000 1000004.将原码转换为十进制打印输出结果是十进制00 0000 0000 0000 0000 0000 0000 100000转换为十进制结果是325. 最终结果就是8 << 2 = 32*/System.out.println("8 << 2 = " + (8 << 2));}
}
  1. 运行LeftShiftBitOperatorPositiveNumberExample2

image

程序运行结果

image

1.6.1.3 左移运算符操作正整数之8 << 28
  1. 新建源文件LeftShiftBitOperatorPositiveNumberExample3.java

image

  1. 编辑源文件LeftShiftBitOperatorPositiveNumberExample3.java

image

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 10002.计算8 << 28左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方0000 0000 0000 0000 0000 0000 0000 1000<< 28=1000 0000 0000 0000 0000 0000 0000 00001000 0000 0000 0000 0000 0000 0000 0000是-2147483648的补码，并且没有原码和反码3. 最终结果就是8 << 28 = -2147483648*/System.out.println("8 << 28 = " + (8 << 28));}
}
  1. 运行LeftShiftBitOperatorPositiveNumberExample3

image

程序运行结果

image

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

image

1.6.2 左移运算符操作负整数

1.6.2.1 左移运算符操作负整数之-8 << 1
  1. 新建源文件LeftShiftBitOperatorNegativeNumberExample1.java

image

  1. 编辑源文件LeftShiftBitOperatorNegativeNumberExample1.java

image

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 10002.计算-8 << 1左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方1111 1111 1111 1111 1111 1111 1111 1000<< 1=111 1111 1111 1111 1111 1111 1111 100003.将补码换算成原码（根据补码求原码）查看运算结果看原码,原码等于补码减1取反①根据补码求反码：反码=补码-1111 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 100004.将原码转换为十进制打印输出结果是十进制100 0000 0000 0000 0000 0000 0000 10000转换为十进制结果是-165. 最终结果就是-8 << 1 = -16*/System.out.println("-8 << 1 = " + (-8 << 1));}
}
  1. 运行LeftShiftBitOperatorNegativeNumberExample1

image

程序运行结果

image

1.6.2.2 左移运算符操作负整数之-8 << 2
  1. 新建源文件LeftShiftBitOperatorNegativeNumberExample2.java

image

  1. 编辑源文件LeftShiftBitOperatorNegativeNumberExample2.java

image

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 10002.计算-8 << 2左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方1111 1111 1111 1111 1111 1111 1111 1000<< 2=11 1111 1111 1111 1111 1111 1111 1000003.将补码换算成原码（根据补码求原码）查看运算结果看原码,原码等于补码减1取反①根据补码求反码：反码=补码-111 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 1000004.将原码转换为十进制打印输出结果是十进制10 0000 0000 0000 0000 0000 0000 100000转换为十进制结果是-325. 最终结果就是-8 << 2 = -32*/System.out.println("-8 << 2 = " + (-8 << 2));}
}
  1. 运行LeftShiftBitOperatorNegativeNumberExample2

image

程序运行结果

image

1.6.2.3 左移运算符操作负整数之-8 << 28
  1. 新建源文件LeftShiftBitOperatorNegativeNumberExample3.java

image

  1. 编辑源文件LeftShiftBitOperatorNegativeNumberExample3.java

image

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 10002.计算-8 << 28左移运算符的运算规则是用于将数据的二进制位向左移动，右边填充0。左移n位在一定范围内就是乘以2的n次方1111 1111 1111 1111 1111 1111 1111 1000<< 28=1000 0000 0000 0000 0000 0000 0000 00001000 0000 0000 0000 0000 0000 0000 0000是-2147483648的补码，并且没有原码和反码3. 最终结果就是-8 << 28 = -2147483648*/System.out.println("-8 << 28 = " + (-8 << 28));}
}
  1. 运行LeftShiftBitOperatorNegativeNumberExample3

image

程序运行结果

image

1.7 右移运算符

1.7.1 右移运算符操作正整数

1.7.1.1 右移运算符操作正整数之8 >> 1
  1. 新建源文件RightShiftBitOperatorPositiveNumberExample1.java

image

  1. 编辑源文件RightShiftBitOperatorPositiveNumberExample1.java

image

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 10002.计算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 1003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码00000 0000 0000 0000 0000 0000 0000 100转换为原码是00000 0000 0000 0000 0000 0000 0000 1004.将原码转换为十进制打印输出结果是十进制00000 0000 0000 0000 0000 0000 0000 100转换为十进制结果是45. 最终结果就是8 >> 1 = 4*/System.out.println("8 >> 1 = " + (8 >> 1));}
}
  1. 运行RightShiftBitOperatorPositiveNumberExample1

image

程序运行结果

image

1.7.1.2 右移运算符操作正整数之8 >> 2
  1. 新建源文件RightShiftBitOperatorPositiveNumberExample2.java

image

  1. 编辑源文件RightShiftBitOperatorPositiveNumberExample2.java

image

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 10002.计算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 103.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码000000 0000 0000 0000 0000 0000 0000 10转换为原码是000000 0000 0000 0000 0000 0000 0000 104.将原码转换为十进制打印输出结果是十进制000000 0000 0000 0000 0000 0000 0000 10转换为十进制结果是25. 最终结果就是8 >> 2 = 2*/System.out.println("8 >> 2 = " + (8 >> 2));}
}
  1. 运行RightShiftBitOperatorPositiveNumberExample2

image

程序运行结果

image

1.7.1.3 右移运算符操作正整数之8 >>4
  1. 新建源文件RightShiftBitOperatorPositiveNumberExample3.java

image

  1. 编辑源文件RightShiftBitOperatorPositiveNumberExample3.java

image

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 10002.计算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 00003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码 0000 0000 0000 0000 0000 0000 0000 0000转换为原码是 0000 0000 0000 0000 0000 0000 0000 00004.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0000转换为十进制结果是05. 最终结果就是8 >> 4 = 0*/System.out.println("8 >> 4 = " + (8 >> 4));}
}
  1. 运行RightShiftBitOperatorPositiveNumberExample3

image

程序运行结果

image

1.7.2 右移运算符操作负整数

1.7.2.1 右移运算符操作负整数之-8 >> 1
  1. 新建源文件RightShiftBitOperatorNegativeNumberExample1.java

image

  1. 编辑源文件RightShiftBitOperatorNegativeNumberExample1.java

image

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 10002.计算-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 1003.将补码换算成原码（根据补码求原码）查看运算结果看原码,原码等于补码减1取反①根据补码求反码：反码=补码-111111 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 1004.将原码转换为十进制打印输出结果是十进制10000 0000 0000 0000 0000 0000 0000 100转换为十进制结果是-45. 最终结果就是-8 >> 1 = -4*/System.out.println("-8 >> 1 = " + (-8 >> 1));}
}
  1. 运行RightShiftBitOperatorNegativeNumberExample1

image

程序运行结果

image

1.7.2.2 右移运算符操作负整数之-8 >> 2
  1. 新建源文件RightShiftBitOperatorNegativeNumberExample2.java

image

  1. 编辑源文件RightShiftBitOperatorNegativeNumberExample2.java

image

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 10002.计算-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 103.将补码换算成原码（根据补码求原码）查看运算结果看原码,原码等于补码减1取反①根据补码求反码：反码=补码-1111111 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 104.将原码转换为十进制打印输出结果是十进制100000 0000 0000 0000 0000 0000 0000 10转换为十进制结果是-25. 最终结果就是-8 >> 2 = -2*/System.out.println("-8 >> 2 = " + (-8 >> 2));}
}
  1. 运行RightShiftBitOperatorNegativeNumberExample2

image

程序运行结果

image

1.7.2.3 右移运算符操作负整数之-8 >> 4
  1. 新建源文件RightShiftBitOperatorNegativeNumberExample3.java

image

  1. 编辑源文件RightShiftBitOperatorNegativeNumberExample3.java

image

 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 10002.计算-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 11113.将补码换算成原码（根据补码求原码）①根据补码求反码：补码-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 00014.将原码转换为十进制打印输出结果是十进制1000 0000 0000 0000 0000 0000 0000 0001转换为十进制结果是-15. 最终结果就是-8 >> 4 = -1*/System.out.println("-8 >> 4 = " + (-8 >> 4));}}
  1. 运行RightShiftBitOperatorNegativeNumberExample3

image

程序运行结果

image

1.8 无符号右移运算符

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

1.8.1.1 无符号右移运算符操作正整数之8 >>> 1
  1. 新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample1.java

image

  1. 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample1.java

image

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 10002.计算8 >>> 1右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充00000 0000 0000 0000 0000 0000 0000 1000>>> 1=00000 0000 0000 0000 0000 0000 0000 1003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码00000 0000 0000 0000 0000 0000 0000 100转换为原码是00000 0000 0000 0000 0000 0000 0000 1004.将原码转换为十进制打印输出结果是十进制00000 0000 0000 0000 0000 0000 0000 100转换为十进制结果是45. 最终结果就是8 >>> 1 = 4*/System.out.println("8 >>> 1 = " + (8 >>> 1));}
}
  1. 运行UnsignedRightShiftBitOperatorPositiveNumberExample1

image

程序运行结果

image

1.8.1.2 无符号右移运算符操作正整数之8 >>> 2
  1. 新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java

image

  1. 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java

image

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 10002.计算8 >>> 2右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充00000 0000 0000 0000 0000 0000 0000 1000>>> 2=000000 0000 0000 0000 0000 0000 0000 103.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码000000 0000 0000 0000 0000 0000 0000 10转换为原码是000000 0000 0000 0000 0000 0000 0000 104.将原码转换为十进制打印输出结果是十进制000000 0000 0000 0000 0000 0000 0000 10转换为十进制结果是25. 最终结果就是8 >>> 2 = 2*/System.out.println("8 >>> 2 = " + (8 >>> 2));}
}
  1. 运行UnsignedRightShiftBitOperatorPositiveNumberExample2

image

程序运行结果

image

1.8.1.3 无符号右移运算符操作正整数之8 >>> 4
  1. 新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java

image

  1. 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java

image

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 10002.计算8 >>> 4右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充00000 0000 0000 0000 0000 0000 0000 1000>>> 4=0000 0000 0000 0000 0000 0000 0000 00003.将补码换算成原码查看运算结果看原码,正数的原码、反码、补码都一样补码0000 0000 0000 0000 0000 0000 0000 0000转换为原码是0000 0000 0000 0000 0000 0000 0000 00004.将原码转换为十进制打印输出结果是十进制0000 0000 0000 0000 0000 0000 0000 0000转换为十进制结果是05. 最终结果就是8 >>> 4 = 0*/System.out.println("8 >>> 4 = " + (8 >>> 4));}
}
  1. 运行UnsignedRightShiftBitOperatorPositiveNumberExample3

image

程序运行结果

image

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

1.8.2.1 无符号右移运算符操作负整数之-8 >>> 1
  1. 新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample1.java

image

  1. 编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample1.java

image

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 10002.计算-8 >>> 1右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充01111 1111 1111 1111 1111 1111 1111 1000>>> 1=01111 1111 1111 1111 1111 1111 1111 1003.将补码换算成原码（根据补码求原码）补码01111 1111 1111 1111 1111 1111 1111 100转换成原码是01111 1111 1111 1111 1111 1111 1111 1004.将原码转换为十进制打印输出结果是十进制01111 1111 1111 1111 1111 1111 1111 100转换为十进制结果是21474836445. 最终结果就是-8 >>> 1 = 2147483644*/System.out.println("-8 >>> 1 = " + (-8 >>> 1));}
}
  1. 运行UnsignedRightShiftBitOperatorNegativeNumberExample1

image

程序运行结果

image

1.8.2.2 无符号右移运算符操作负整数之-8 >>> 2
  1. 新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java

image

  1. 编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java

image

 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 10002.计算-8 >>> 2右移运算符的运算规则是用于将数据的二进制位向右移动，左边填充01111 1111 1111 1111 1111 1111 1111 1000>>> 1=00111 1111 1111 1111 1111 1111 1111 1003.将补码换算成原码（根据补码求原码）补码00111 1111 1111 1111 1111 1111 1111 100转换成原码是00111 1111 1111 1111 1111 1111 1111 1004.将原码转换为十进制打印输出结果是十进制00111 1111 1111 1111 1111 1111 1111 100转换为十进制结果是10737418205. 最终结果就是-8 >>> 2 =1073741820*/System.out.println("-8 >>> 2 = " + (-8 >>> 2));}}
  1. 运行UnsignedRightShiftBitOperatorNegativeNumberExample2

image

程序运行结果

image

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. 新建包

image

  1. 新建源文件AssignmentOperatorUsage.java

image

  1. 编辑源文件AssignmentOperatorUsage.java

image

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) {//赋值运算符使用方式1System.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);//赋值运算符使用方式2int 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));}
}
  1. 运行AssignmentOperatorUsage

image

程序运行结果

image

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

  1. 新建源文件ExtendsAssignmentOperatorUsage.java

image

  1. 编辑源文件ExtendsAssignmentOperatorUsage.java

image

 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);}}
  1. 运行ExtendsAssignmentOperatorUsage

image

程序运行结果

image

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

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

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

  1. 新建源文件AssignmentOperatorWarning1.java

image

  1. 编辑源文件AssignmentOperatorWarning1.java

image

 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);}}
  1. 运行AssignmentOperatorWarning1

image

程序运行结果

image

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

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

  1. 新建源文件AssignmentOperatorWarning2.java

image

  1. 编辑源文件AssignmentOperatorWarning2.java

image

 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);}}
  1. 运行AssignmentOperatorWarning2

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

image

程序运行结果

image

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

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

  1. 新建源文件AssignmentOperatorWarning3.java

image

  1. 编辑源文件AssignmentOperatorWarning3.java

image

 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);}}
  1. 运行AssignmentOperatorWarning3

image

程序运行结果

image

2.4 赋值运算符案例

2.4.1 实现变量值加1

  1. 新建源文件AssignmentOperatorExample1.java

image

  1. 编辑源文件AssignmentOperatorExample1.java

image

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);}
}
  1. 运行AssignmentOperatorExample1

image

程序运行结果

image

2.4.2 实现变量值加2

  1. 新建源文件AssignmentOperatorExample2.java

image

  1. 编辑源文件AssignmentOperatorExample2.java

image

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);}
}
  1. 运行AssignmentOperatorExample2

image

程序运行结果

image

3. 三种数据交换的方式

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

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

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

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

缺点：需要开辟临时空间

  1. 新建源文件DataExchangeWithTemp.java

image

  1. 编辑源文件DataExchangeWithTemp.java

image

   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 =10int temp = left;//① right = 20 ② left =20left = right;//① temp = 10 ② right =10right = temp;System.out.println("数据交换实现方式1:基于临时变量实现交换之后");System.out.printf("left = %d  right = %d \n", left, right);}}
  1. 运行DataExchangeWithTemp

image

程序运行结果

image

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

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

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

  1. 新建源文件DataExchangeWithArithmeticOperator.java

image

  1. 编辑源文件DataExchangeWithArithmeticOperator.java

image

 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 + 20left = left + right;//right = 10right = left - right;//left = 30 - 10left = left - right;System.out.println("数据交换实现方式2:使用算术运算(加减法)实现交换之后");System.out.printf("left = %d  right = %d \n", left, right);}}
  1. 运行DataExchangeWithArithmeticOperator

image

程序运行结果

image

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

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

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

  1. 新建源文件DataExchangeWithXorOperator.java

image

  1. 编辑源文件DataExchangeWithXorOperator.java

image

 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);}}
  1. 运行DataExchangeWithXorOperator

image

程序运行结果

image

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/191593.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

java Lock锁的使用

java Lock锁的使用

Lock接口 public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); }这 5 种方法分别是 lock(…
阅读更多...
网络虚拟化场景下网络包的发送过程

网络虚拟化场景下网络包的发送过程

网络虚拟化有和存储虚拟化类似的地方&#xff0c;例如&#xff0c;它们都是基于 virtio 的&#xff0c;因而在看网络虚拟化的过程中&#xff0c;会看到和存储虚拟化很像的数据结构和原理。但是&#xff0c;网络虚拟化也有自己的特殊性。例如&#xff0c;存储虚拟化是将宿主机上…
阅读更多...
python绘制箱线图boxplot——用于多组数据的比较， 异常值检测

python绘制箱线图boxplot——用于多组数据的比较， 异常值检测

python绘制箱线图boxplot——用于多组数据的比较， 异常值检测 介绍箱线图方法简介箱线图适用范围seaborn.boxplot箱图外观设置异常值marker形状、填充色、轮廓设置完整代码 如下matplotlib.pyplot常见参数介绍 本文系统详解利用python中seaborn.boxplot绘制箱图boxplot。seab…
阅读更多...
跟着chatgpt一起学|2.clickhouse入门（1）

跟着chatgpt一起学|2.clickhouse入门（1）

上周我们一起学习了spark&#xff0c;这周让chatgpt帮我们规划下clickhouse的学习路径吧&#xff01; 目录 ​编辑 1.了解Clickhouse的基本概念 1.1 Clickhouse是什么&#xff1f; 1.2 ClickHouse的特点和优势 1.3 Clickhouse的基本架构与组件 1.了解Clickhouse的基本概念…
阅读更多...
链式队列的结构设计及基本操作的实现（初始化，入队，出队，获取元素个数，判空，清空，销毁）

链式队列的结构设计及基本操作的实现（初始化，入队，出队，获取元素个数，判空，清空，销毁）

目录 一.链式队列的设计思想 二.链式队列的结构设计 三.链式队列的实现 四.链式队列的总结 一.链式队列的设计思想 首先一定要理解设计的初衷,就是队头队尾的位置要满足怎么快怎么设计.那么分析如下: 最终我们敲定了入队,出队的时间复杂度都为O(1)的一种设计,也就是第四种设…
阅读更多...
LDO版图后仿性能下降

LDO版图后仿性能下降

记录一下LDO&#xff0c;debug 问题1&#xff1a; LDO后仿输出电压下降&#xff0c;前仿输出1.8V&#xff0c;后仿却输出只有1.58V。 解决办法&#xff1a; 功率管的走线问题&#xff0c;布线太少&#xff0c;存在IR drop问题。功率管的面积比较大&#xff0c;需要横竖都多…
阅读更多...
面试--各种场景问题总结

面试--各种场景问题总结

1.在开发过程中&#xff0c;你是如何保证机票系统的正常运行的&#xff1f; 用户、测试、监控和日志、安全措施、数据备份、系统设计、需求分析 2.在机票系统开发过程中&#xff0c;你最有成就的事情&#xff0c;为什么&#xff1f; 用户体验感、高可用和稳定性、客户满意度、系…
阅读更多...
什么情况下会导致索引失效

什么情况下会导致索引失效

程序员的公众号&#xff1a;源1024&#xff0c;获取更多资料&#xff0c;无加密无套路&#xff01; 最近整理了一份大厂面试资料《史上最全大厂面试题》&#xff0c;Springboot、微服务、算法、数据结构、Zookeeper、Mybatis、Dubbo、linux、Kafka、Elasticsearch、数据库等等 …
阅读更多...
SSM实战项目，基于Spring+SpringMVC+mybatis实现的人事管理系统源码+数据库+使用说明

SSM实战项目，基于Spring+SpringMVC+mybatis实现的人事管理系统源码+数据库+使用说明

SSM实战项目&#xff1a;人事管理系统&#xff08;蓝色版&#xff09; 一、员工管理系统项目说明&#xff1a; 该项目主要是完成SpringSpringMVCmybatis的完整整合&#xff0c;功能实现比较单一&#xff0c;就是一个完成增删改查的小项目&#xff01; 完整代码下载地址SSM实…
阅读更多...
Python zip函数及用法与lambda表达式及用法

Python zip函数及用法与lambda表达式及用法

Python zip函数及用法 zip() 函数可以把两个列表“压缩”成一个 zip 对象&#xff08;可迭代对象&#xff09;&#xff0c;这样就可以使用一个循环并行遍历两个列表。为了测试 zip() 函数的功能&#xff0c;我们可以先在交互式解释器中“试验”一下该函数的功能。 >>&g…
阅读更多...
软件工程期末复习（1）

软件工程期末复习（1）

学习资料 软件工程知识点总结_嘤桃子的博客-CSDN博客 软件工程学习笔记_软件工程导论第六版张海藩pdf-CSDN博客 【软件工程】软件工程期末试卷习题课讲解&#xff01;&#xff01;_哔哩哔哩_bilibili 【拯救者】软件工程速成(期末考研复试软考)均适用. 支持4K_哔哩哔哩_bil…
阅读更多...
redis单线程为什么这么快

redis单线程为什么这么快

redis单线程为什么这么快 redis是使用的单线程来进行操作的&#xff0c;因为所有的数据都是在内存中的&#xff0c;内存操作特别快。而且单线程避免了多线程切换性能损耗问题 单线程如何处理并发客户端连接&#xff1f; redis利用epoll来实现IO多路复用&#xff0c;将连接信息和…
阅读更多...
【halcon】C# halcon 内存暴增

【halcon】C# halcon 内存暴增

1 读取图片需要及时手动释放 一个6M的图片通过halcon进行加载&#xff0c;大约会消耗200M的内存&#xff0c;如果等待GC回收&#xff0c;而你又在不停的读取图片&#xff0c;你的内存占用&#xff0c;将在短时间内飙升。 2 halcon控件显示图片需要清空。 /// <summary>…
阅读更多...
dp-带权活动选择

dp-带权活动选择

Description 给定n个活动&#xff0c;活动ai表示为一个三元组(si,fi,vi)&#xff0c;其中si表示活动开始时间&#xff0c;fi表示活动的结束时间&#xff0c;vi表示活动的权重, si<fi。带权活动选择问题是选择一些活动&#xff0c;使得任意被选择的两个活动ai和aj执行时间互不…
阅读更多...
dataframe.values.tolist() 举例说明

dataframe.values.tolist() 举例说明

dataframe.values.tolist() 是将 Pandas DataFrame 中的数据转换为嵌套的 Python 列表&#xff08;list of lists&#xff09;。这将返回一个包含 DataFrame 所有行和列的嵌套列表。以下是一个简单的例子&#xff1a; 假设有如下的 DataFrame&#xff1a; import pandas as p…
阅读更多...
【Unity记录】EDM4U(External Dependency Manager)使用说明

【Unity记录】EDM4U(External Dependency Manager)使用说明

GitHub - googlesamples/unity-jar-resolver: Unity plugin which resolves Android & iOS dependencies and performs version management 引入谷歌包时发现有这个玩意&#xff0c;主要用途是自动搜索工程内任意文件夹下的Editor/*Dependencies.xml文件 <dependencie…
阅读更多...
基于eBPF检测内核模块安装行为

基于eBPF检测内核模块安装行为

本文实现一个简单的示例&#xff0c;展示了如何编写一个eBPF程序来检测未知内核模块的安装行为。 首先&#xff0c;请确保系统已安装eBPF工具链。然后&#xff0c;创建一个名为unknown_module_detection.c的C文件&#xff0c;并使用以下代码填充内容&#xff1a; c #include …
阅读更多...
D*算法学习

D*算法学习

系列文章目录 A*算法学习-CSDN博客 弗洛伊德算法&#xff08;Floyd&#xff09;和路径平滑弗洛伊德算法&#xff08;Smooth Floyd&#xff09;学习-CSDN博客 目录 系列文章目录 前言 一、D*算法是什么&#xff1f; 二、D* 算法是对 A* 算法的改进 三、增量搜索是什么 总…
阅读更多...
梯度爆炸梯度消失

梯度爆炸梯度消失

梯度消失和梯度爆炸是深度学习中常见的问题&#xff0c;与神经网络的训练相关。这两个问题都涉及到梯度在反向传播过程中的传递。 梯度消失&#xff08;Gradient Vanishing&#xff09;&#xff1a; 当神经网络较深时&#xff0c;反向传播过程中梯度可能逐层减小&#xff0c;最…
阅读更多...
【FMC139】青翼科技基于VITA57.1标准的4路500MSPS/1GSPS/1.25GSPS采样率14位AD采集FMC子卡模块

【FMC139】青翼科技基于VITA57.1标准的4路500MSPS/1GSPS/1.25GSPS采样率14位AD采集FMC子卡模块

板卡概述 FMC139是一款基于VITA57.1标准规范的JESD204B接口FMC子卡模块&#xff0c;该模块可以实现4路14-bit、500MSPS/1GSPS ADC采集功能。该板卡ADC器件采用ADI公司的AD9680芯片,全功率-3dB模拟输入带宽可达2GHz。该ADC与FPGA的主机接口通过8通道的高速串行GTX收发器进行互联…
阅读更多...
最新文章

Copyright @ 2022~2023