【韩顺平Java笔记】第4章：运算符

61. 上一章总结

看视频

62. 算术运算符介绍

62.1 运算符介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

1. 算术运算符；
2. 赋值运算符；
3. 关系运算符[比较运算符]；
4. 逻辑运算符；
5. 位运算符；
6. 三元运算符

62.2 算术运算符介绍

算术运算符是对数值类型的变量进行运算的，在Java车光绪中使用的非常多。

62.3 算术运算符一览

63. 算术运算符使用

演示代码：

public class ArithmeticOperator
{
    public static void main(String[] args)
    {
        System.out.println(10 / 4);//运算符两边精度最高的都是int，所以结果也是int（2）
        System.out.println(10.0 / 4);//精度最高的是double类型，结果是2.5
        double d = 10/4;//精度最高的还是int，所以结果先算成int类型，即2，再转成double，即2.0
        System.out.println(d);
        //取模
        //%得本质，看一个公式a % b =a - a / b * b
        //-10 % 3 => -10 - (-10)/3*3=-10 - (-3)*3=-1
        //10 % -3 => 10 - 10/(-3)*(-3)=10 - 9 =1
        //-10 % 3 => -10 - (-10)/3 * 3=-10 + 9 =-1
        System.out.println(10 % 3);//10/3求余数，得1
        System.out.println(-10 % 3);//-1
        System.out.println(10 % -3);//1
        System.out.println(-10 % -3);//-1
        //++的使用
        int i = 10;
        i++;//独立使用++，放前面和放后面是一样的
        ++i;
        System.out.println("i=" + i);
        /*
         * 作为表达式使用
         * 前++ : ++i先自增后赋值
         * 后++ : i++先赋值后自增
         */
        int j = 8;
        int k = ++j;//等价于两条语句j=j+1;k=j;
        System.out.println("k=" + k + "\nj=" + j);//9 9
        int j1 = 8;
        int k1 = j1++;//等价于两条语句k1=j1;j1=j1+1;
        System.out.println("k1=" + k1 + "\nj1=" + j1);//8  9
    }
}

运行结果：
2
2.5
2.0
1
-1
1
-1
i=12
k=9
j=9
k1=8
j1=9

64. 算术运算符练习1

1. int i = 1;
   i = i++;
   System.out.println(i);
   问：结果是多少？为什么？
   【答】（1）使用临时变量：temp = i;
   （2）i = i+1;
   （3）i = temp;
   所以输出的结果是1

2. int i = 1;
   i = ++i;
   System.out.println(i);
   【答】（1）i = i+1;
   （2）temp = i;
   （3）i = temp;
   所以输出的结果是2

65. 算术运算符练习2

• 自增，自减课堂练习，看看输出什么

int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i);
System.out.println("i2="+i2);
i= --i2;
System.out.print("i="+i);
System.out.println("i2="+i2);

【答】输出结果为：
i=10i2=20
i=19i2=19
int i = i1++;//先给i1赋值给temp变量temp为10，然后i1自增1变为11，然后i变为temp的值10
i= --i2;// i2先自减，i2变为19，然后temp变为i2当前值19，将temp的值赋值给i，i也变为19

66. 67. 算术运算符练习3,4

1. 假如还有59天放假，问：合xx个星期零xx天。
2. 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为5/9*（华氏温度-100），请求出华氏温度234.5度对应的摄氏温度。
   【答】

public class ArithmeticOperatorExercise02
{
    public static void main(String[] args)
    {
        //需求：假如还有59天放假，问：合xx个星期零xx天。
        //思路分析：
        //（1）使用int变量days保存天数
        //（2）一个星期是7天 星期数weeks： days / 7 零 xx天 leftDays % 7
        //（3）输出
        int days = 59;
        int weeks = days / 7;
        int leftDays = days % 7;
        System.out.println("合" + weeks + "个星期零" + leftDays + "天");
        //需求：定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为5/9*（华氏温度-100），请求出华氏温度234.5度对应的摄氏温度。
        //思路分析
        //(1)先定义一个double huaShi 变量保存 华氏温度
        //(2)根据给出的公式，进行计算即可5/9*(华氏温度-100)，考虑数学公式和java语言的特性
        //(3)将得到的结果保存到double sheShi
        double huaShi = 234.5;
        double sheShi = 5 / 9.0 * (huaShi - 100);//注意变量中得有double类型，写个9.0，要不然就变成整数的除法会出现精度丢失
        System.out.println("华氏温度" + huaShi + "对应的摄氏温度=" + sheShi);
    }
}

运行结果：
合8个星期零3天
华氏温度234.5对应的摄氏温度=74.72222222222223

68. 关系运算符介绍

68.1 关系运算符介绍

1. 关系运算符的结果都是boolean型，也就是要么是true，要么是false
2. 关系表达式经常用在if结构的条件中或循环结构的条件中

68.2 关系运算符一览

69. 关系运算符使用

public class RelationOperator {
    public static void main(String[] args) {
        int a = 9;// 提示:开发中，不可以使用 a, b a1,bc n1,n2...
        int b = 8;
        System.out.println(a > b);//T
        System.out.println(a >= b);//T
        System.out.println(a <= b);//F
        System.out.println(a < b);//F
        System.out.println(a == b);//F
        System.out.println(a != b);//T
        boolean flag = a > b;//T
        System.out.println("flag=" + flag);
    }
}

运算结果：
true
true
false
false
false
true
flag=true

• 细节说明
  1)关系运算符的结果都是boolean型，也就是要么是true，要么是false。
  2)关系运算符组成的表达式，我们称为关系表达式。a>b
  3)比较运算符"==“不能误写成”="

70. 逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个boolean值。

70.1 逻辑运算符一览

1)短路与 &&，短路或||，取反!
2)逻辑与&，逻辑或|，^逻辑异或
其真值表如下：

• 说明逻辑运算规则：

1. a&b:& 叫逻辑与:规则:当a 和 b 同时为true,则结果为true,否则为false
2. a&&b:&& 叫短路与:规则:当a 和b 同时为true ,则结果为true,否则为false
3. alb : | 叫逻辑或，规则:当a 和 b，有一个为true,则结果为true,否则为false
4. alb : | 叫短路或，规则:当a 和 b，有一个为true ,则结果为true,否则为false
5. !a:叫取反，或者非运算。当a 为true,则结果为false,当a为false是，结果为true
6. a^b: 叫逻辑异或，当 a和 b 不同时，则结果为true,否则为false

71. 短路与逻辑与

71.1 &&和&基本规则

71.2 &&和&使用区别

短路与和逻辑与其运算结果一样，但是它们是有区别的。

1. &&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
2. & 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
3. 开发中， 我们使用的基本是使用短路与&&, 效率高
   演示代码：

public class LogicOperator01
{
    public static void main(String[] args)
    {
        //&& 和 &案例演示
        int age = 50;
        if(age > 20 && age < 90)
        {
            System.out.println("ok100");
        }
        if(age > 20 & age < 90)
        {
            System.out.println("ok200");
        }
        //区别
        int a = 4;
        int b = 9;
        //对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断
        //对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断
        //a<1为假，假与真结果为假，不输出
        if(a < 1 && ++b < 50)
        {
            System.out.println("ok300");
        }
        //输出a=4,b=9，++b并没有执行
        System.out.println("a=" + a);
        System.out.println("b=" + b);
        if(a < 1 & ++b < 50)
        {
            System.out.println("ok300");
        }
        //输出a=4,b=10，++b执行了
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
}

运行结果：
ok100
ok200
a=4
b=9
a=4
b=10

72. 短路或逻辑或

72.1 ||和|基本规则

72.2 || 和 | 使用区别

1. ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
2. | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
3. 开发中，我们基本使用 ||

演示代码：

public class LogicOperator02
{
    public static void main(String[] args)
    {
        //||短路或 和 |逻辑或 案例演示
        //|| 规则: 两个条件中只要有一个成立，结果为 true,否则为 false
        //| 规则: 两个条件中只要有一个成立，结果为 true,否则为 false
        int age = 50;
        //有一个为真则为真
        if(age > 20 || age < 30) 
        {
            System.out.println("ok100");
        }
        if(age > 20 | age < 30) 
        {
            System.out.println("ok200");
        }
        //看看区别
        //(1)||短路或：如果第一个条件为 true，
        //则第二个条件不会判断，最终结果为 true，效率高
        //(2)| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
        int a = 4;
        int b = 9;
        if(a>1 || ++b > 4)
        {
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b); //4 9
        if(a>1 | ++b > 4)
        {
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b); //4 10
    }
}

运行结果：
ok100
ok200
ok300
a=4 b=9
ok300
a=4 b=10

73. 逻辑非逻辑异或

73.1 逻辑非

取反的基本规则：

73.2 逻辑异或

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

演示代码：

public class InverseOperator
{
    public static void main(String[] args)
    {
        //! 操作是取反 T->F , F -> T
        System.out.println(60 > 20); //T
        System.out.println(!(60 > 20)); //F
        //a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false
        boolean b = (10 > 1) ^ ( 3 > 5);
        System.out.println("b=" + b);//T
    }
}

运行结果：
true
false
b=true

74. 逻辑运算符练习

练习题 1 请写出每题的输出结果

详细可以看视频，规则就是上面那些运算符的规则

练习题 2 请写输出结果

if((z++==46)&&(y=true)) z++;//z和46先比较，再自增，所以第一个条件为True，第二个条件y=true后的结果为true，所以逻辑与的结果为true，z++执行；
下面同理

75. 赋值运算符介绍

75.1 介绍

赋值运算符就是将某个运算后的值，赋给指定的变量。

75.2 赋值运算符的分类

基本赋值运算符 =
复合赋值运算符
+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理
a += b; [等价 a = a + b; ]
a -= b; [等价 a = a - b; ]

76. 赋值运算符细节

赋值运算符特点

1. 运算顺序从右往左 int num = a + b + c;
2. 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值
   int num = 20; int num2= 78 * 34 - 10; int num3 = a;
3. 复合赋值运算符等价于下面的效果
   比如：a+=3;等价于 a=a+3; 其他类推
4. 复合赋值运算符会进行类型转换。
   byte b = 2; b+=3; b++;

public class AssignOperator
{
    public static void main(String[] args) 
    {
        int n1 = 10;
        n1 += 4;// n1 = n1 + 4
        System.out.println(n1);
        n1 /= 3;//n1 = n1 / 3
        System.out.println(n1);//4
        //复合赋值运算符会进行类型转换
        byte b = 3;//符合-128~127
        b += 2; // 等价于b = b + 2;，这个b+2结果是int值，按理说是不正确的，但是它是赋值运算符，能够自动转换类型为byte，所以正确
        b++; //同理也可以
    }
}

运行结果：
14
4

77. 三元运算符介绍

条件表达式 ? 表达式 1: 表达式 2;
运算规则：

1. 如果条件表达式为 true，运算后的结果是表达式 1；
2. 如果条件表达式为 false，运算后的结果是表达式 2；

演示代码：

public class TernaryOperator
{
    public static void main(String[] args) 
    {
        int a = 10;
        int b = 99;
        // 解读
        // 1. a > b 为 false
        // 2. 返回 b--, 先返回 b 的值,然后在 b-1，如果是--b，那先b自减，再返回自减后的b的值
        // 3. 返回的结果是 99
        int result = a > b ? a++ : b--;
        System.out.println("result=" + result);
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
}

运行结果：
result=99
a=10
b=98

78. 三元运算符细节

1. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
2. 三元运算符可以转成 if–else 语句
   int res = a > b ? a++ : --b;
   等价为
   if ( a > b) res = a++;
   else res = --b;

public class TernaryOperatorDetail
{
    public static void main(String[] args) 
    {
        //表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
        int a = 3;
        int b = 8;
        int c = a > b ? a : b;//返回a和b的最大值
        //int c1 = a > b ? 1.1 : 3.4;//返回a和b的最大值，错误，不能给double赋值给int，自动转换只能从低精度到高精度，加上强制类型转换就ok
        double d = a> b ? a : b + 3;//低精度到高精度可以
    }
}

79. 三元运算符练习

案例：实现三个数的最大值

public class TernaryOperatorExercise
{
    public static void main(String[] args) 
    {
        int n1 = 55;
        int n2 = 33;
        int n3 = 123;
        //思路
        //1. 先得到n1和n2中最大数，保存到max1
        //2. 然后再求出max1 和 n3中的最大数，保存到max2

        int max1 = n1 > n2 ? n1 : n2;
        int max2 = max1 > n3 ? max1 : n3;
        System.out.println("最大数=" + max2);
        //使用一条语句实现
        //上面更清晰，可读性强
        //后面用更好的方法来解决
        int max = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3;
        System.out.println("最大数=" + max);
    }
}

运行结果：
最大数=123
最大数=123

80. 运算符优先级

1. 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
2. 只有单目运算符、赋值运算符是从右向左运算的。
3. 一览表, 不要背，使用多了，就熟悉了
   
   【注】L代表left左，R代表Right右
   

81. 标识符规则

• 标识符的命名规则和规范

81.1 标识符概念

1. Java对各种变量、方法和类等命名时使用的字符序列称为标识符；
2. 凡是可以自己起名字的地方都叫标识符 int num1 = 90;

81.2 标识符的命名规则（必须遵守）

1. 由26个英文字母大小写，数字0-9，_或$组成；比如int a b;不可以（因为中间有空格）
2. 数字不可以开头。 错误例子如int 3ab = 1;
3. 不可以使用关键字（比如class）和保留字，但可以包含关键字和保留字（比如abcclass）；
4. Java中严格区分大小写，长度无限制。比如：int totalNum = 10; int totalnum = 90;是两个不同的变量
5. 标识符不能包含空格。int a b = 90;

82. 标识符练习

hsp //ok
hsp12 //ok
1hsp //错误, 数字不能开头
h-s // 错误 , 不能有 - x h // 错误， 有空格
h$4 // ok
class //错误，class 关键字
int // 错误 ,int 是关键字
double //错误 ,double 是关键字
public //错误 ,public 是关键字
static //错误 ,static 是关键字
goto //错误, goto 是保留字
stu_name //ok

83. 标识符规范

1. 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
2. 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
   比如： TankShotGame
3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小
   驼峰， 简称 驼峰法]
   比如： tankShotGame
4. 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
   比如 ：定义一个所得税率 TAX_RATE
5. 后面我们学习到 类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.

84. 关键字保留字

84.1 关键字

关键字的定义和特点 (不用背)
定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

84.2 保留字

Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

86. 键盘输入

86.1 介绍

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。需要一个 扫描器(对象), 就是Scanner.

86.2 步骤

1. 导入该类的所在包, java.util.*
2. 创建该类对象（声明变量）
3. 调用里面的功能

86.3 案例演示

要求：可以从控制台接收用户信息，【姓名，年龄，薪水】

import java.util.Scanner;//表示把java.util包下的Scanner类导入
public class Input
{
    public static void main(String[] args) 
    {
        //演示接收用户的输入
        //步骤
        //Scanner类表示简单文本扫描器，在java.util包
        //1. 引入/导入 Scanner类所在的包
        //2. 创建Scanner对象，new创建一个对象
        //myScanner就是Scanner类的对象
        Scanner myScanner = new Scanner(System.in);
        //3. 接收用的输入，使用相关的方法
        System.out.println("请输入名字");
        //当程序执行到next方法时，会等待用户输入
        String name = myScanner.next(); //接收用户输入字符串，nextInt输入Int，以此类推，可看开发文档
        System.out.println("请输入年龄"); //接收用户输入int
        int age = myScanner.nextInt();
        System.out.println("请输入薪水");
        double sal = myScanner.nextDouble(); //接收用户输入double
        System.out.println("人的信息如下：");
        System.out.println("姓名：" + name + " 年龄=" + age + " 薪水" + sal);
    }
}

输入与输出结果：
请输入名字
jack
请输入年龄
18
请输入薪水
10000
人的信息如下：
姓名：jack 年龄=18 薪水10000.0

86. 四种进制介绍

86.1 进制介绍

对于整数，有四种表示方式：
二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。
十进制：0-9 ，满 10 进 1。
八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。
十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

//演示四种进制
public class BinaryTest
{
    public static void main(String[] args) 
    {
        //n1 二进制
        int n1 = 0b1010;//2^1+2^3=2+8=10
        //n2 10 进制
        int n2 = 1010;
        //n3 8 进制
        int n3 = 01010;
        //n4 16 进制
        int n4 = 0X10101;
        System.out.println("n1=" + n1);
        System.out.println("n2=" + n2);
        System.out.println("n3=" + n3);
        System.out.println("n4=" + n4);
        System.out.println(0x23A);
    }
}

运行结果：
n1=10
n2=1010
n3=520
n4=65793
570

86.2 进制的图示

87. 二进制转十进制

【注】韩顺平老师提到的这些进制转换，均未涉及到符号位（负数）的问题，关于符号位的问题可以看计算机组成原理的书

88. 八进制转十进制

89. 十六进制转十进制

规则：从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。
案例：请将 0x23A 转成十进制的数
0x23A = 10 * 16^0 + 3 * 16 ^ 1 + 2 * 16^2 = 10 + 48 + 512 = 570
课堂练习：请将
0b110001100 转成 十进制
【答】$0\text{b}110001100=2^2+2^3+2^7+2^8=396$
02456 转成十进制
【答】$02456=6\times 8^0+5\times 8^1+4\times 8^2+2\times 8^3=1326$
0xA45 转成十进制
【答】$0\text{xA}45=5\times 16^0+4\times 16^1+10\times 16^2=2629$

90. 十进制转二进制

规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：请将 34 转成二进制 = 0B00100010

【注】0B00100010前面多两个0是因为一个字节有8位，要补一下。

91. 十进制转八进制

规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
案例：请将 131 转成八进制 => 0203

92. 十进制转十六进制

规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：请将 237 转成十六进制 => 0xED

课堂练习：(一定练习，使用计算器/用程序去验证)
123 转成 二进制 => ?
【答】0B01111011

678 转成八进制 => ?
【答】01246

8912 转成十六进制 => ?
【答】0X22D0

93. 二进制转八进制

规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
案例：请将 0b11010101 转成八进制
0b11(3)010(2)101(5) => 0325

94. 二进制转十六进制

规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
案例：请将 ob11010101 转成十六进制
ob1101(D)0101(5) = 0xD5
课堂练习：请将
0b11100101 转成 八进制
【答】0b1110(14,E)0101(5) = 0xE5
0b1110010110 转成 十六进制
【答】0b11(3)1001(9)0110(6)=0x396

95. 八进制转二进制

规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。
案例：请将 0237 转成二进制
02(010)3(011)7(111) = 0b10011111
【注】保持一个字节8位二进制，最左侧的0可以省略

96. 十六进制转二进制

规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
案例：请将 0x23B 转成二进制
0x2(0010)3(0011)B(1011) = 0b001000111011
课堂练习：请将
01230 转成 二进制
【答】1(001)2(010)3(011)0(000)=0B1010011000
0xAB29 转成二进制
【答】0xA(1010)B(1011)2(0010)9(1001)=0B1010 1011 0010 1001

97. 位运算的思考题

抛砖引玉引出两个题目，以便后面介绍位运算

1. 请看下面的代码段，回答 a,b,c,d,e 结果是多少?

public static void maiin(String []args)
{
	int a=1>>2; // 1 向右位移 2 位
	int b=-1>>2;//算术右移
	int c=1<<2;//算术左移
	int d=-1<<2;//
	int e=3>>>2;//无符号右移
	//a,b,c,d,e 结果是多少
	System.out.println("a="+a);
	System.out.println("b="+b);
	System.out.println("c="+c);
	System.out.println("d="+d);
	System.out.println("e="+e);
}

2. 请回答在 java 中，下面的表达式运算的结果是: (位操作)
   ~2=? // 按位取反
   2&3=?// 2 按位与 3
   2|3=? ~-5=?
   13&7=?
   5|4=?
   -3^3=?//^ 按位异或

98. 原码，反码，补码

98.1 二进制在运算中的说明

1. 二进制是逢2进位的进位制，0、1是基本算符。
2. 现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制(Binary)数用0和1两个数字及其组合来表示任何数。进位规则是"逢2进1"，数字1在不同的位上代表不同的值，按从右至左的次序，这个值以二倍递增。

98.2 源码、反码、补码（重点 难点）

网上对原码,反码,补码的解释过于复杂，我这里精简几句话:
对于有符号的而言:

1. 二进制的最高位是符号位:0表示正数,1表示负数(口诀:0->0 1->-)
2. 正数的原码，反码，补码都一样(三码合一)
3. 负数的反码=它的原码符号位不变，其它位取反(0->1,1->0)
4. 负数的补码=它的反码+1，负数的反码= 负数的补码-1
5. 0的反码，补码都是0
6. java没有无符号数，换言之，java中的数都是有符号的
7. 在计算机运算的时候，都是以补码的方式来运算的.
8. 当我们看运算结果的时候，要看他的原码

99. 位运算详解1

java 中有 7 个位运算(&、|、^ 、~、>>、<<和 >>>)

public class BitOperator
{
    public static void main(String[] args) 
    {
        //先得到2的补码，这两个数都是int型，占四个字节，（正数补码就是原码）
        //所以2的补码为00000000 00000000 00000000 00000010B
        //3的补码为00000000 00000000 00000000 00000011B
        //按位与的结果为00000000 00000000 00000000 00000010B（补码）
        //结果的补码恰好是正数，补码就是原码
        //即十进制的2
        System.out.println(2 & 3);
        //-2原码为10000000 00000000 00000000 00000010
        //-2的反码为11111111 11111111 11111111 11111101（反码符号位不变）
        //-2的补码为反码+1即11111111 11111111 11111111 11111110
        //然后对-2的补码按位取反00000000 00000000 00000000 00000001（按位取反符号位变）
        //即运算后的补码为00000000 00000000 00000000 00000001
        //正数，则补码就是原码，即十进制的1
        System.out.println(~-2);
        //2是正数，补码就是原码，即00000000 00000000 00000000 00000010
        //对2的补码取反就是11111111 11111111 11111111 11111101
        //得到结果的补码是11111111 11111111 11111111 11111101
        //对结果的补码-1就是反码即11111111 11111111 11111111 11111100
        //结果的反码的反码就是原码即10000000 00000000 00000000 00000011
        //（取反码和取反不同，取反码符号位不变，取反符号位也变）
        //也就是十进制的-3
        System.out.println(~2);
        //2的补码为00000000 00000000 00000000 00000010B
        //3的补码为00000000 00000000 00000000 00000011B
        //按位或结果的补码为00000000 00000000 00000000 00000011B
        //正数，补码和原码一样，即十进制的3
        System.out.println(2|3);
        //2的补码为00000000 00000000 00000000 00000010B
        //3的补码为00000000 00000000 00000000 00000011B
        //按位异或结果的补码为00000000 00000000 00000000 00000001B
        //正数，补码和原码一样，即十进制的1
        System.out.println(2^3);
    }
}

运行结果：
2
1
-3
3
1

100. 位运算详解2

还有 3 个位运算符 >>、<< 和 >>> , 运算规则:

1. 算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
2. 算术左移 <<: 符号位不变,低位补 0
3. >>>逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0
4. 特别说明：没有 <<< 符号

public class BitOperator02
{
    public static void main(String[] args) 
    {
        //1 => 0000000 00000000 00000000 000000(01)B，用符号位补括号的内容
        //即变成0000000 00000000 00000000 00000000B
        //它的本质是1/2/2 == 0
        System.out.println(1>>2);
        //1 => 0000000 00000000 00000000 000000(01)B，将括号和其括号前面除符号位外左移两位
        //空出来的右侧的两位补0，即
        //0000000 00000000 00000000 00000100B
        //它的本质是1*2*2=4
        System.out.println(1<<2);
        System.out.println(4<<3);//相当于4*2*2*2=4*2的3次方=32
        System.out.println(15>>2);//相当于15/2/2=15/(2的平方)=3(int类型，除法损失精度)
        //前面的题
        int a=1>>2; // 1 向右位移 2 位（除两次2，结果为0）
        //-1的原码是10000000 00000000 00000000 00000001B
        //-1的反码是11111111 11111111 11111111 11111110B
        //-1的补码是11111111 11111111 11111111 111111(11)B
        //算数右移，符号位补溢出的高位，即(11)及其左侧向右移动（除符号位，空出来的两个位用符号位补齐）
        //结果的补码为11111111 11111111 11111111 11111111B
        //和-1的补码一致，所以b=-1>>2还是-1
	    int b=-1>>2;//算术右移
        //1*2*2=4
	    int c=1<<2;//算术左移
        //-1的原码是10000000 00000000 00000000 00000001B
        //-1的反码是11111111 11111111 11111111 11111110B
        //-1的补码是11111111 11111111 11111111 111111(11)B
        //左移两位，符号位不变，低位补0，(11)及其左侧非符号位向左移动
        //结果的补码是11111111 11111111 11111111 11111100B
        //结果的反码是补码-1即11111111 11111111 11111111 11111011B（借位减法）
        //结果的原码是反码的反码即10000000 00000000 00000000 00000100B
        //即十进制的-4
        //也即-1*2*2=-4
	    int d=-1<<2;//
        //3的二进制是00000000 00000000 00000000 00000011B
        //正数，补码和原码一致
        //无符号右移，低位溢出，高位补0，右移动2位
        //得到结果的补码是00000000 00000000 00000000 00000000B
        //正数，补码和原码一致，即十进制的0
	    int e=3>>>2;//无符号右移
	    //a,b,c,d,e 结果是多少
	    System.out.println("a="+a);
	    System.out.println("b="+b);
	    System.out.println("c="+c);
	    System.out.println("d="+d);
	    System.out.println("e="+e);
    }
}

运行结果为：
0
4
32
3
a=0
b=-1
c=4
d=-4
e=0
【注】带符号右移不仅仅是简单的除以2：它还包含了对符号位的处理，以保持数的符号不变。如果你期望通过右移实现严格的数学除法，这种行为可能会让结果与预期不符，特别是对于负数。

101. 本章作业

1. 计算下列表达式的结果
   10/3 = ?;
   10/5 = ?;
   10%2 = ?;
   -10.5%3 = ?;
   【答】10/3 == 3
   10/5 == 2
   10%2 == 0
   -10.5 % 3（按公式a % b = a - (int)a / b * b即$$a\%b=a-\lfloor \frac{a}{b}\rfloor \cdot b$$） ==-10.5-((-10.5)/3) *3==-10.5+3*3(标了小数点就是double类型)==-1.5
   【注】有小数运算，得到结果是近似值。
2. 试说出下面代码的结果
   int i = 66;
   System.out.println(++i+i);
   【答】
   ++i是先让i自增然后再做运算（i++是先做运算，运算后自增），即i自增变成67后，然后再进行i+i，即67+67，输出结果是134