运算符

• 算数运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=，instanceof
• 逻辑运算符：&&，||，!
• 位运算符：&，|，^，~，>>，<<，>>>
• 条件运算符：? :
• 扩展运算符：+=，-=，*=，/=

算数运算符

int a = 20;
int b = 20;

System.out.println("a + b = " + (a + b));
// 输出：a + b = 20

System.out.println("a - b = " + (a - b));
// 输出：a - b = 0

System.out.println("a * b = " + (a * b));
// 输出：a * b = 400

System.out.println("a / b = " + (a / b));
// 输出：a / b = 1

// 这里是取余运算
// 例如：20 % 3，结果为 2
// 20 % 3  =  6 余 2
// 3 * 6 = 18
// 18 + 2 = 20
// 余运算就是整除后获取余下的数值
System.out.println("a % b = " + (a % b));
// 输出：a % b = 0

// ++ 在前面，相当于运算先运算 a = a + 1，然后将 a 打印出来，得到的结果 21 。
System.out.println(" ++ a = " + (++ a));
// 输出：++ a = 21

// ++ 在后面，相当于先打印 a ，然后再运算 a = a + 1 ，那么打印的结果就是 21 ，这里打印出来的就是 21 ，然后再计算 a = a + 1 ，再次打印 a 的话，得到的就是 22
System.out.println(" a ++ = " + (a ++));
// 输出：a ++ = 21
System.out.println(" a ++ 运算后再次打印 a = " + (a));
// 输出： a ++ 运算后再次打印 a = 22

// 注意，目前 a 的结果是 22
// -- 与 ++ 的逻辑一样，同样要看它是在前面还是后面
// -- 在前面，相当于运算先运算 a = a - 1，然后将 a 打印出来，得到的结果 21 。
System.out.println(" -- a = " + (-- a));
// 输出：-- a = 21

// -- 在后面，相当于先打印 a ，然后再运算 a = a - 1 ，那么打印的结果就是 21 ，这里打印出来的就是 21 ，然后再计算 a = a - 1 ，再次打印 a 的话，得到的就是 20
System.out.println(" a -- = " + (a --));
// 输出：a -- = 21
System.out.println(" a -- 运算后再次打印 a = " + (a));
// 输出： a -- 运算后再次打印 a = 20

赋值运算符

• 就是将一个值赋予一个变量

int a = 10;
// 这里就是将数字 10 赋予 a 这个变量。

关系运算符

• 多用于判断比较，可以配合 if 使用

int a = 10;
int b = 20;

if (a > b) {
  // a 小于 b，该语句不打印
  System.out.println("a 大于 b");
}
if (a < b) {
  // a 小于 b，该语句打印
  System.out.println("a 小于 b");
}
if (a >= b) {
  // a 小于 b，该语句不打印
  System.out.println("a 大于等于 b");
}
if (a <= b) {
  // a 小于等于 b，该语句打印
  System.out.println("a 小于等于 b");
}
if (a == b) {
  // a 不等于 b，该语句不打印
  System.out.println("a 等于 b");
}
if (a != b) {
  // a 不等于 b，该语句打印
  System.out.println("a 不等于 b");
}

// instanceof 用于判断其左边的对象是否为其右边类的实例。
Integer c = 20;
if (c instanceof Integer) {
  System.out.println("c 的类型是 Integer");
}

逻辑运算符

// &&，||，!

// && 表示并且的意思，和 and 类似
// || 表示或者的意思
// ! 表示非
// 以上运算符查用于条件判断中

boolean x = true;
boolean z = false;

// 如果 x 等于 true，并且 z 等于 false，那么就打印，以上条件成立，语句被打印
if (x == true && z == false) {
  System.out.println("&& 条件成立");
}

// || 表示或者的意思，和 or 类似
// 如果 x 等于 true，或者 z 等于 false，那么就打印，以上条件成立，语句被打印
// 因为是或者的关系，只要一个条件满足，那么就会打印，虽然条件二 z 等于 true 不成立，但是 x 等于 true 成立
if (x == true || z == true) {
  System.out.println("|| 条件成立");
}
// 这里涉及到短路运算规则，|| 的条件判断是依次从左到右进行的，只要触发了一次成立的条件，后面的判断就会直接不执行，因为这是没有必要的，因为程序通过的条件是多个条件只要成立一条就可以了
// 可以这样尝试
int a = 1;
if (((++ a) == 2) || ((a --) == 2) ) {
  System.out.println("最终 a = " + a);
  // 输出：最终 a = 2
  // 条件 a -- 并没有被执行，因为如果 a -- 执行了的话，a 的结果就是 a = 1
  // 因为这里是或者的逻辑，所以 ((++ a) == 2) 条件成立了，那么 || 后面的程序就不在执行了，这就是短路原则
}

// ! 表示非的，取反的意思
boolean b = true;
System.out.println(" ! b = " + (!b));
// b 的值是 true，非 true ，那就是 false

位运算符

• 需要记住，计算机存储数据是以补码的形式进行存储的

// &，|，^，~，>>，<<，>>>
// 位运算符本质上是二进制数据的处理
// 其本质是将 long、int、short、byte 和 char 这 5 种类型的数据转换为二进制，再进行相关运算操作
// 注意，位运算符只能运算整形，不能运算浮点型，所以位运算符不可以处理 double、float 和 boolean 值

int a = 30;
int b = 25;
// 先将数值转为二进制
// a = 30 = 0001 1110
// b = 25 = 0001 1001

// &：按位与运算，两个位都为 1 时，结果才为 1
System.out.println(a & b);
// 输出：24
// a =  0001 1110
// b =  0001 1001
// 结果：0001 1000
// 0001 1000 = 24

// |：按位或运算，两个位都为 0 时，结果才为 0
System.out.println(a | b);
// 输出：31
// a =  0001 1110
// b =  0001 1001
// 结果：0001 1111
// 0001 1111 = 31

// ^：异或运算，两个位相同为 0，相异为 1
System.out.println(a ^ b);
// 输出：7
// a =  0001 1110
// b =  0001 1001
// 结果：0000 0111
// 0000 0111 = 7


// ~：取反运算，0 变 1 , 1 变 0
System.out.println( ~ a);
// 输出：-31
// 首先符号数值化，正数的原码、反码、补码都一样
// 原码：0000 0000 0000 0000 0000 0000 0001 1110
// 反码：0000 0000 0000 0000 0000 0000 0001 1110
// 补码：0000 0000 0000 0000 0000 0000 0001 1110
// 最终的运算是以补码进行的
// 取反操作
// 取反后得到一个负数的补码
// 补码：1111 1111 1111 1111 1111 1111 1110 0001
// 负数反码到补码是加一，这里回溯操作就是减一，得到下面的反码
// 反码：1111 1111 1111 1111 1111 1111 1110 0000
// 负数的原码转反码是按位取反，这里回溯的话也是一样取反，得到一个原码
// 原码：1000 0000 0000 0000 0000 0000 0001 1111
// 第一位表示该值为负数，后面的 0001 1111 的十进制值为 31 ，最后带入负数，得到：-31

// a =  30 （原码，第一个零表示该值为整数）
// 原码：0001 1110
// 取反操作，就是执行了 ~ 位运算符，得到以下结果
// 取反：1001 1110（取反，第一个一表示该值为负数，）
// 计算机存储数据是已补码的形式存储的
// 补码：1001 1111 （补码，第一个一表示该值为负数）
// 最终系统中存储的就是 - 31

// >>：右移运算
System.out.println("a >> 1 = " + (a >> 1));
// 输出：a >> 1 = 15
// 将数值转换位二进制
// 原码：0001 1110
// 右移运算，整体右移一位，得到：0000 1111
// 0000 1111  =  15
// 最终的结果相当于除二

// <<：左移运算
System.out.println("a << 1 = " + (a << 1));
// 输出：a << 1 = 60
// 将数值转换位二进制
// 原码：0001 1110
// 左移运算，整体左移一位，得到：0011 1100
// 0011 1100  =  60
// 最终的结果相当于乘二


// >>>：无符号右移运算，忽略了符号位扩展，0 补最高位
System.out.println("a >>> 1 = " + (a >>> 1));
// 输出：a >>> 1 = 15
// 将数值转换位二进制（已 32 位系统为例）
// 原码：0000 0000 0000 0000 0000 0000 0001 1110（第一位 0 是符号位，表示正数）
// 无符号右移运算，整体右移一位
// 原码：000 0000 0000 0000 0000 0000 0000 1111（第一位 0 是符号位，表示正数）

int x = -30;
System.out.println("x >>> 1 = " + (x >>> 1));
// 输出：x >>> 1 = 2147483633
// 将数值转换位二进制（已 32 位系统为例）
// 系统存储是以补码的方式存储的，负数的存储需要先原码转反码再补码（第一位不动）
// 原码：1000 0000 0000 0000 0000 0000 0001 1110（第一位 1 是符号位，表示负数）
// 反码：1111 1111 1111 1111 1111 1111 1110 0001
// 补码：1111 1111 1111 1111 1111 1111 1110 0010（补码加一）
// 无符号右移运算，负数的补码整体右移一位，确实位补零，得到的就是正数，正数的补码、反码、原码都一样
// 补码：0111 1111 1111 1111 1111 1111 1111 0001

条件运算符

// ? :
// 用于三元表达式
// true ? 执行 : 不执行
// false ? 不执行 : 执行
// x ? y : z
// 如果 x == true，则结果为 y，否则结果为 z

int age = 18
String lable = age >= 18 ? "成年" : "未成年";
System.out.println(lable );
// 输出：成年

--

扩展运算符

// +=，-=，*=，/=
// 简写

int a = 10;
int b = 20;

// a = a + b
a += b;
System.out.println(a);
// 输出：30

// a = a - b
a -= b;
System.out.println(a);
// 输出：10

// a = a * b
a *= b;
System.out.println(a);
// 输出：200

// a = a / b
a /= b;
System.out.println(a);
// 输出：10