网站标题能改吗,微信开发小程序公司,关键词搜索优化外包,建设网站的规则1. 位运算符
Q#xff1a;为什么要学习位运算
A#xff1a;由于其运算效率更高#xff0c;在JDK源码#xff08;例如ArrayList、HashMap#xff09;中大量使用位运算#xff0c;想要看懂JDK源码必须懂位预算#xff0c;但是在公司开发业务系统时位运算使用并不多。 Q…
1. 位运算符
Q为什么要学习位运算
A由于其运算效率更高在JDK源码例如ArrayList、HashMap中大量使用位运算想要看懂JDK源码必须懂位预算但是在公司开发业务系统时位运算使用并不多。 Q学习位运算需要提前储备哪些知识点
A由于位运算底层运算是基于二进制因此需要掌握计算机进制包括二进制、十进制以及它们之间的相互转换由于计算机数据底层都是基于补码进行运算查看结果需要转换为原码因此还需要了解原码、反码、补码以及它们之间的相互转换。
1.1 位运算符介绍
Java提供了7个位运算符
位运算符说明计算规则按位与按照二进制位进行与运算同1为1有0为0|按位或按照二进制位进行或运算有1为1同0为0^按位异或按照二进制位进行异或运算相同为0不同为1~按位取反按照二进制位取反1为00为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 18601767221163.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 01010000 0000 0000 0000 0000 0000 0000 00100000 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));}
}运行BitAndOperatorPositiveNumberExample1 程序运行结果 1.2.1.2 按位与运算符操作正整数之5 3
新建源文件BitAndOperatorPositiveNumberExample2.java 编辑源文件BitAndOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位与运算符操作正整数之 5 3** author tony 18601767221163.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 01010000 0000 0000 0000 0000 0000 0000 00110000 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));}}
运行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 18601767221163.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 10111111 1111 1111 1111 1111 1111 1111 11011111 1111 1111 1111 1111 1111 1111 10013.将补码换算成原码根据补码求原码①根据补码求反码补码-1反码1111 1111 1111 1111 1111 1111 1111 1001-11111 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));}
}运行BitAndOperatorNegativeNumberExample1 程序运行结果 1.2.2.2 按位与运算符操作负整数之 -5 -10
新建源文件BitAndOperatorNegativeNumberExample2.java 编辑源文件BitAndOperatorNegativeNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位与运算符操作负整数之 -5 -10** author tony 18601767221163.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 10111111 1111 1111 1111 1111 1111 1111 01101111 1111 1111 1111 1111 1111 1111 00103.将补码换算成原码根据补码求原码①根据补码求反码补码-1反码1111 1111 1111 1111 1111 1111 1111 0010-11111 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));}}
运行BitAndOperatorNegativeNumberExample2 程序运行结果 1.2.2.3 按位与运算符操作负整数之5 -10
新建源文件BitAndOperatorNegativeNumberExample3.java 编辑源文件BitAndOperatorNegativeNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位与运算符操作负整数之5 -10** author tony 18601767221163.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的补码补码反码15的补码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 01011111 1111 1111 1111 1111 1111 1111 01100000 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));}
}运行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 18601767221163.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 00100000 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));}
}运行BitOrOperatorPositiveNumberExample1 程序运行结果 1.3.1.2 按位或运算符操作正整数之 5 | 3
新建源文件BitOrOperatorPositiveNumberExample2.java 编辑源文件BitOrOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位或运算符操作正整数之 5 | 3** author tony 18601767221163.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 00110000 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));}
}运行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 18601767221163.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 11011111 1111 1111 1111 1111 1111 1111 11113.将补码换算成原码根据补码求原码①根据补码求反码补码-1反码1111 1111 1111 1111 1111 1111 1111 1111-11111 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));}
}运行BitOrOperatorNegativeNumberExample1 程序运行结果 1.3.2.2 按位或运算符操作负整数之 -5 |-10
新建源文件BitOrOperatorNegativeNumberExample2.java 编辑源文件BitOrOperatorNegativeNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位或运算符操作负整数之 -5 |-10** author tony 18601767221163.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 01101111 1111 1111 1111 1111 1111 1111 11113.将补码换算成原码根据补码求原码①根据补码求反码补码-1反码1111 1111 1111 1111 1111 1111 1111 1111-11111 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));}
}运行BitOrOperatorNegativeNumberExample2 程序运行结果 1.3.2.3 按位或运算操作负整数之 5 |-10
新建源文件BitOrOperatorNegativeNumberExample3.java 编辑源文件BitOrOperatorNegativeNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位或运算符操作负整数之 5 |-10** author tony 18601767221163.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的补码补码反码15的补码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 01101111 1111 1111 1111 1111 1111 1111 01113.将补码换算成原码①根据补码求反码反码补码-11111 1111 1111 1111 1111 1111 1111 0111-11111 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));}}
运行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 18601767221163.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 00100000 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));}
}运行BitXorOperatorPositiveNumberExample1 程序运行结果 1.4.1.2 按位异或运算符操作正整数之 5 ^ 3
新建源文件BitXorOperatorPositiveNumberExample2.java 编辑源文件BitXorOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位异或运算符操作正整数之 5 ^ 3** author tony 18601767221163.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 00110000 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));}
}运行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 18601767221163.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 11010000 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));}
}运行BitXorOperatorNegativeNumberExample1 程序运行结果 1.4.2.2 按位异或运算符操作负整数之 -5 ^ -10
新建源文件BitXorOperatorNegativeNumberExample2.java 编辑源文件BitXorOperatorNegativeNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位异或运算符操作负整数之 -5 ^ -10** author tony 18601767221163.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 01100000 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));}
}运行BitXorOperatorNegativeNumberExample2 程序运行结果 1.4.2.3 按位异或运算符操作负整数之 5 ^ -10
新建源文件BitXorOperatorNegativeNumberExample3.java 编辑源文件BitXorOperatorNegativeNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位异或运算符操作负整数之 5 ^ -10** author tony 18601767221163.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的补码补码反码15的补码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 01101111 1111 1111 1111 1111 1111 1111 00113.将补码换算成原码①根据补码求反码反码补码-11111 1111 1111 1111 1111 1111 1111 0011-11111 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));}}运行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 18601767221163.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为00为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-11111 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));}
}运行BitNotOperatorPositiveNumberExample1 程序运行结果 1.5.1.2 按位取反运算符操作正整数之~10
新建源文件BitNotOperatorPositiveNumberExample2.java 编辑源文件BitNotOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位取反运算符操作正整数之~10** author tony 18601767221163.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为00为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-11111 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));}
}运行BitNotOperatorPositiveNumberExample2 程序运行结果 1.5.2 按位取反运算符操作负整数
1.5.2.1 按位取反运算符操作负整数之 ~-5
新建源文件BitNotOperatorNegativeNumberExample1.java 编辑源文件BitNotOperatorNegativeNumberExample1.java package net.ittimeline.java.core.foundational.operator.bit;/*** 按位取反运算符操作负整数之~-5** author tony 18601767221163.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为00为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));}}运行BitNotOperatorNegativeNumberExample1 程序运行结果 1.5.2.2 按位取反运算符操作负整数之~-10
新建源文件BitNotOperatorNegativeNumberExample2.java 编辑源文件BitNotOperatorNegativeNumberExample2 package net.ittimeline.java.core.foundational.operator.bit;/*** 按位取反运算符操作负整数之~-10** author tony 18601767221163.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为00为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));}
}运行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 18601767221163.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 1000 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));}}
运行LeftShiftBitOperatorPositiveNumberExample1 程序运行结果 1.6.1.2 左移运算符操作正整数之8 2
新建源文件LeftShiftBitOperatorPositiveNumberExample2.java 编辑源文件LeftShiftBitOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 左移运算符操作正整数之8 2** author tony 18601767221163.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 200 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));}
}运行LeftShiftBitOperatorPositiveNumberExample2 程序运行结果 1.6.1.3 左移运算符操作正整数之8 28
新建源文件LeftShiftBitOperatorPositiveNumberExample3.java 编辑源文件LeftShiftBitOperatorPositiveNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 左移运算符操作正整数之8 28** author tony 18601767221163.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 281000 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));}
}运行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 18601767221163.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 1111 1111 1111 1111 1111 1111 1111 100003.将补码换算成原码根据补码求原码查看运算结果看原码,原码等于补码减1取反①根据补码求反码反码补码-1111 1111 1111 1111 1111 1111 1111 10000-1111 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));}
}运行LeftShiftBitOperatorNegativeNumberExample1 程序运行结果 1.6.2.2 左移运算符操作负整数之-8 2
新建源文件LeftShiftBitOperatorNegativeNumberExample2.java 编辑源文件LeftShiftBitOperatorNegativeNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 左移运算符操作负整数之-8 2** author tony 18601767221163.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 211 1111 1111 1111 1111 1111 1111 1000003.将补码换算成原码根据补码求原码查看运算结果看原码,原码等于补码减1取反①根据补码求反码反码补码-111 1111 1111 1111 1111 1111 1111 100000-111 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));}
}运行LeftShiftBitOperatorNegativeNumberExample2 程序运行结果 1.6.2.3 左移运算符操作负整数之-8 28
新建源文件LeftShiftBitOperatorNegativeNumberExample3.java 编辑源文件LeftShiftBitOperatorNegativeNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 左移运算符操作负整数之-8 28** author tony 18601767221163.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 281000 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));}
}运行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 18601767221163.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 100000 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));}
}运行RightShiftBitOperatorPositiveNumberExample1 程序运行结果 1.7.1.2 右移运算符操作正整数之8 2
新建源文件RightShiftBitOperatorPositiveNumberExample2.java 编辑源文件RightShiftBitOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 右移运算符操作正整数之8 2** author tony 18601767221163.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 2000000 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));}
}运行RightShiftBitOperatorPositiveNumberExample2 程序运行结果 1.7.1.3 右移运算符操作正整数之8 4
新建源文件RightShiftBitOperatorPositiveNumberExample3.java 编辑源文件RightShiftBitOperatorPositiveNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 右移运算符操作正整数之8 4** author tony 18601767221163.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 20000 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));}
}运行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 18601767221163.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 111111 1111 1111 1111 1111 1111 1111 1003.将补码换算成原码根据补码求原码查看运算结果看原码,原码等于补码减1取反①根据补码求反码反码补码-111111 1111 1111 1111 1111 1111 1111 100-111111 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));}
}运行RightShiftBitOperatorNegativeNumberExample1 程序运行结果 1.7.2.2 右移运算符操作负整数之-8 2
新建源文件RightShiftBitOperatorNegativeNumberExample2.java 编辑源文件RightShiftBitOperatorNegativeNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 右移运算符操作负整数之-8 2** author tony 18601767221163.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 2111111 1111 1111 1111 1111 1111 1111 103.将补码换算成原码根据补码求原码查看运算结果看原码,原码等于补码减1取反①根据补码求反码反码补码-1111111 1111 1111 1111 1111 1111 1111 10-1111111 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));}
}运行RightShiftBitOperatorNegativeNumberExample2 程序运行结果 1.7.2.3 右移运算符操作负整数之-8 4
新建源文件RightShiftBitOperatorNegativeNumberExample3.java 编辑源文件RightShiftBitOperatorNegativeNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 右移运算符操作负整数之-8 4** author tony 18601767221163.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 41111 1111 1111 1111 1111 1111 1111 11113.将补码换算成原码根据补码求原码①根据补码求反码补码-1反码1111 1111 1111 1111 1111 1111 1111 1111-11111 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));}}
运行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 18601767221163.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 100000 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));}
}运行UnsignedRightShiftBitOperatorPositiveNumberExample1 程序运行结果 1.8.1.2 无符号右移运算符操作正整数之8 2
新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 无符号右移运算符操作正整数之8 2** author tony 18601767221163.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 2000000 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));}
}运行UnsignedRightShiftBitOperatorPositiveNumberExample2 程序运行结果 1.8.1.3 无符号右移运算符操作正整数之8 4
新建源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java 编辑源文件UnsignedRightShiftBitOperatorPositiveNumberExample3.java package net.ittimeline.java.core.foundational.operator.bit;/*** 无符号右移运算符操作正整数之8 4** author tony 18601767221163.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 40000 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));}
}运行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 18601767221163.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 101111 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));}
}运行UnsignedRightShiftBitOperatorNegativeNumberExample1 程序运行结果 1.8.2.2 无符号右移运算符操作负整数之-8 2
新建源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java 编辑源文件UnsignedRightShiftBitOperatorNegativeNumberExample2.java package net.ittimeline.java.core.foundational.operator.bit;/*** 无符号右移运算符操作负整数之-8 2** author tony 18601767221163.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 100111 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));}}运行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 left10,right 20;赋值表达式本身也是有值其值就是给变量赋的值。
int value 10;
System.out.println(赋值表达式value100的结果是 (value 100));赋值运算符还可以结合算术运算符、位运算符使用组成扩展赋值运算符
赋值运算符结合算术运算符
扩展赋值运算符说明将符号左边的值和右边的值进行相加操作最后将结果赋值给左边的变量-将符号左边的值和右边的值进行相减操作最后将结果赋值给左边的变量*将符号左边的值和右边的值进行相乘操作最后将结果赋值给左边的变量/将符号左边的值和右边的值进行相除操作最后将结果赋值给左边的变量%将符号左边的值和右边的值进行取余操作最后将结果赋值给左边的变量
赋值运算符结合位运算符
扩展赋值运算符说明将符号左边的值和右边的值进行按位与操作最后将结果赋值给左边的变量|将符号左边的值和右边的值进行按位或操作最后将结果赋值给左边的变量^将符号左边的值和右边的值进行按位异或操作最后将结果赋值给左边的变量将符号左边的值和右边的值进行左移操作最后将结果赋值给左边的变量将符号左边的值和右边的值进行右移操作最后将结果赋值给左边的变量将符号左边的值和右边的值进行无符号右移操作最后将结果赋值给左边的变量
2.2 赋值运算符使用
2.2.1 赋值运算符基本使用
新建包 新建源文件AssignmentOperatorUsage.java 编辑源文件AssignmentOperatorUsage.java package net.ittimeline.java.core.foundational.operator.assignment;/*** 基本赋值运算符的使用** author tony 18601767221163.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(赋值表达式value100的结果是 (value 100));}
}运行AssignmentOperatorUsage 程序运行结果 2.2.2 扩展赋值运算符基本使用
新建源文件ExtendsAssignmentOperatorUsage.java 编辑源文件ExtendsAssignmentOperatorUsage.java package net.ittimeline.java.core.foundational.operator.assignment;/*** 扩展赋值运算符使用** author tony 18601767221163.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);}}运行ExtendsAssignmentOperatorUsage 程序运行结果 2.3 赋值运算符使用注意事项
2.3.1赋值运算符使用注意事项1
赋值运算符的运算顺序是从右往左
新建源文件AssignmentOperatorWarning1.java 编辑源文件AssignmentOperatorWarning1.java package net.ittimeline.java.core.foundational.operator.assignment;/*** 赋值运算符注意事项1** author tony 18601767221163.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);}}运行AssignmentOperatorWarning1 程序运行结果 2.3.2 赋值运算符使用注意事项2
赋值运算符的左边只能是变量右边可以是字面量、变量或者表达式
新建源文件AssignmentOperatorWarning2.java 编辑源文件AssignmentOperatorWarning2.java package net.ittimeline.java.core.foundational.operator.assignment;/*** 赋值运算符注意事项2** author tony 18601767221163.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);}}
运行AssignmentOperatorWarning2
运行之前将第17行和第18行编译错误的地方注释 程序运行结果 2.3.3 赋值运算符使用注意事项3
复合赋值运算符不会改变变量的数据类型
新建源文件AssignmentOperatorWarning3.java 编辑源文件AssignmentOperatorWarning3.java package net.ittimeline.java.core.foundational.operator.assignment;/*** 赋值运算符使用注意事项3** author tony 18601767221163.com* version 2023/12/2 20:19* since Java21*/public class AssignmentOperatorWarning3 {public static void main(String[] args) {//复合赋值运算符不会改变变量的数据类型byte byteVar 10;//等价于byteVar (byte) (byteVar10)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 18601767221163.com* version 2023/12/2 20:26* since Java21*/
public class AssignmentOperatorExample1 {public static void main(String[] args) {//方式1int type1 1;type1 1;System.out.println(type1 type1);//方式2int type2 1;type2 type2 1;System.out.println(type2 type2);//方式3推荐int type3 1;type3;System.out.println(type3 type3);//方式4int 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 18601767221163.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);//方式2int 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 18601767221163.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);}}
运行DataExchangeWithTemp 程序运行结果 3.2 使用算术运算实现数据交换
优势不需要开辟临时空间
缺点适用性差不支持非数值类型、可能超出int类型的范围
新建源文件DataExchangeWithArithmeticOperator.java 编辑源文件DataExchangeWithArithmeticOperator.java package net.ittimeline.java.core.foundational.operator;/*** 数据交换实现方式2使用算术运算实现数据交换** author tony 18601767221163.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);}}运行DataExchangeWithArithmeticOperator 程序运行结果 3.3 使用异或运算实现数据交换
优势不需要开辟临时空间
缺点适用性差不适用非数值类型)、难以理解和维护
新建源文件DataExchangeWithXorOperator.java 编辑源文件DataExchangeWithXorOperator.java package net.ittimeline.java.core.foundational.operator;/*** 数据交换实现方式3使用异或运算实现数据交换** author tony 18601767221163.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);}}运行DataExchangeWithXorOperator 程序运行结果
