Java 运算符详解(取模、位运算、运算符的执行顺序) 您所在的位置:网站首页 位运算符的运算顺序 Java 运算符详解(取模、位运算、运算符的执行顺序)

Java 运算符详解(取模、位运算、运算符的执行顺序)

2024-06-16 17:45| 来源: 网络整理| 查看: 265

title: 运算符categories:

JavaSEtags: Java JavaSEauthor:name: 龙link: https://github.com/hwlong019date: 2023-09-19 15:08:48permalink: /pages/ef0cfa/ 05.运算符 算数运算符 运算符 用途 + 加法运算,字符串连接运算,正号 - 减法运算,负号 * 乘法运算 / 除法运算,当参与 / 运算的两个操作数都是整数时, 表示整数除法;否则, 表示浮点除法。整数被 0 除将会产生一个异常, 而浮点数被 0 除将会得到无穷大或 NaN 结果。 % 取模运算,两个数字相除取余数 公式:a % b = a - a / b * b 当a是小数时,公式:a % b = a - (int)a / b * b ++、-- 自增自减运算

++运算,变量自己增长1。 --运算,变量自己减少1,用法与++一致。

独立运算:变量在独立运算时,前++(i++) 和 后++(++i)没有区别。 混合运算: 前++(i++),变量先+1,然后使用结果。【先加后用】 后++(++i),先使用变量本来的数值,然后变量+1。【先用后加】

+符号在字符串中的操作:

+ 符号在遇到字符串的时候,表示连接、拼接的含义。 "a"+"b"的结果是"ab",连接含义。

运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种。

public static void main(String[] args) { System.out.println(10 / 4); // 2 整数运算结果也是整数 System.out.println(10.0 / 4); // 2.5 double a = 10 / 4; // 先整数运算10/4得到2,再转换为double类型,得到2.0 System.out.println(a); // 取模 % // 公式:a % b = a - a / b * b System.out.println(10 % 3); // 1 System.out.println(-10 % 3); // -1 // -10 - (-10) / 3 * 3 // -10 - (-3) * 3 // -10 - (-9) // -10 + 9 // -1 System.out.println(10 % -3); // 1 // 10 - 10 / (-3) * (-3) // 10 - (-3) * (-3) // 10 - 9 // 1 System.out.println(-10 % -3); // -1 System.out.println(-10.5 % 3); // -1.5 // -10.5 - (int)(-10.5) / 3 * 3 // -10.5 - (-10) / 3 * 3 // -10.5 - (-3) * 3 // -10.5 - (-9) // -10.5 + 9 // -1.5 // ++ int i = 10; i++; ++i; System.out.println("i = " + i); // 作为表达式使用 // 前++: ++i 先自增,再使用 // 后++: i++ 先使用,后自增 int j = 8; // int k = ++j; // 等价于 j = j + 1; k = j; 两条语句 int k = j++; // 等价于 k = j; j = j + 1; 两条语句 System.out.println("k = " + k + ", j = " + j); }

练习:

int i = 1; i = i++; System.out.println(i); // i 的输出结果为【1】 /* 使用临时变量:temp 1. 因为是 i++,所以先使用 2. temp = i; 3. i = i + 1; 4. i = temp; 5. 得到结果为1 */ int i = 1; i = ++i; System.out.println(i); // i 的输出结果为【2】 /* 使用临时变量:temp 1. 因为是 ++i,所以先自增 2. i = i + 1; 3. temp = i; 4. i = temp; 5. 得到结果为2 */ 赋值运算符

赋值运算符,就是将符号右边的值,赋给左边的变量。如果运算符得到一个值, 其类型与左侧操作数的类型不同, 就会发生强制类型转换。

赋值运算符 描述 \= 等于号 += 加等于 x += 4; 等价于:x = x + 4; -= 减等于 *= 乘等于 /= 除等于 %= 取模等

运算顺序从右往左int num = a + b + c;。

赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值

复合赋值运算符会进行类型转换。 byte b = 2; b+=3; b++;

public class AssignOperator{ public static void main(String[] args) { int n1 = 10; n1 += 4; System.out.println(n1); // 14 n1 /= 3; System.out.println(n1); // 4 byte b = 3; b += 2; // 等价于 b = (byte)(b + 2); b++; // 等价于 b = (byte)(b + 1); } } 关系运算符 运算符 描述 \== 比较符号两边数据是否相等,相等结果是true 比较符号左边的数据是否大于右边的数据,如果大于结果是true = 比较符号左边的数据是否大于或者等于右边的数据,如果小于结果是true != 不等于符号 ,如果符号两边的数据不相等,结果是true instanceof 判断是否为类的对象 "aaa" instanceof String 结果为true

关系运算符,是两个数据之间进行比较的运算,运算结果都是布尔值 true 或者 false 。

关系运算符组成的表达式,我们称为关系表达式。

public class RelationalOperator{ public static void main(String[] args) { int a = 9; int b = 8; System.out.println(a > b); // true System.out.println(a >= b); // true System.out.println(a public static void main(String[] args) { int age = 50; if (age > 20 && age System.out.println("ok200"); } int a = 4; int b = 9; if (a System.out.println("ok400"); } System.out.println("d = " + d); // d = 10 int e = 4; int f = 9; if (e > 1 || ++f System.out.println("ok400"); } System.out.println("h = " + h); // h = 10 System.out.println(!(60 > 20)); // false System.out.println(!(60 1) ^ (3 1) ^ (3 > 5); System.out.println("j = " + j); // true } }

练习:

boolean x = true; boolean y = false; short z = 46; if ((z++ == 46) && (y = true)) { z++; } if ((x = false) || (++z) == 49) { z++; } System.out.println("z = " + z); // 50 三元运算符 条件表达式 ? 表达式1 : 表达式2;

三元运算符计算方式:

条件表达式结果是true,三元运算符整体结果为表达式1。 条件表达式结果是false,三元运算符整体结果为表达式2。

必须同时保证表达式A和表达式B都符合左侧数据类型的要求。三元运算符的结果必须被使用。

三元运算符可以转成if--else语句

表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)

public class TernaryOperator { public static void main(String[] args) { int a = 10; int b = 99; // 1. a > b 为false // 2. 得到表达式 b-- // 3. 因为是 后--,先将b的值赋给result // 4. result的值为99,b的值为98 int result = a > b ? a++ : b--; System.out.println("result = " + result); System.out.println("b = " + b); } }

三元运算符是一个整体,会返回范围最大的那个,比如:

System.out.println(true ? 1 : 2.0);

会输出:1.0

位运算符

处理整型类型时,可以直接对组成整型数值的各个位完成操作。这意味着可以使用掩码技术得到整数中的各个位。

运算符 描述 & ("and") 按位与 两位全为1,结果为1,否则为0 **\ ("or")** 按位或 两位有一个为1,结果为1,否则为0 ^ ("xor") 按位异或 两位一个为0,一个为1,结果为1,否则为0 ~ ("not") 按位取反 0为1,1为0 public class TernaryOperatorDetail { public static void main(String[] args) { /* 计算 (2 & 3): * 1. 因为计算机中都是以补码的形式计算的,所以先得到2的补码 * 2. 2为int型,4字节,所以原码为 00000000 00000000 00000000 00000010 * 3. 正数的原码和补码是一样的,所以2的补码为 00000000 00000000 00000000 00000010 * 4. 同理,3的原码和补码为 00000000 00000000 00000000 00000011 * 5. 按位运算 & (两位全为1,结果为1,否则为0) * 00000000 00000000 00000000 00000010 * & 00000000 00000000 00000000 00000011 * ———————————————————————————————————————— * 00000000 00000000 00000000 00000010 * 6. 运算后得到的是补码,将补码转为原码(因为第一位是0,所以是正数,则三码合一) * 7. 转换为十进制的值为 2 * */ System.out.println(2 & 3); /* 计算 (~-2) * 1. 先得到-2的原码 10000000 00000000 00000000 00000010 * 2. 计算-2的反码(原码符号位不变,其他位取反) 11111111 11111111 11111111 11111101 * 3. 计算-2的补码(它的反码+1) 11111111 11111111 11111111 11111110 * 4. 取反运算 ~ (0为1,1为0) * ~ 11111111 11111111 11111111 11111110 * ———————————————————————————————————————— * 00000000 00000000 00000000 00000001 * 5. 运算后得到的是补码,将补码转为原码(因为第一位是0,所以是正数,则三码合一) * 6. 转换为十进制的值为 1 * */ System.out.println(~-2); /* 计算 (~2) * 1. 先得到2的原码 00000000 00000000 00000000 00000010 * 2. 计算2的补码(三码合一) 00000000 00000000 00000000 00000010 * 3. 取反运算 ~ (0为1,1为0) * ~ 00000000 00000000 00000000 00000010 * ———————————————————————————————————————— * 11111111 11111111 11111111 11111101 * 4. 运算后得到的是补码,将补码转为原码(因为第一位是1,所以是负数) * 5. 首先补码转反码(负数的反码等于负数的补码-1) 11111111 11111111 11111111 11111100 * 6. 反码转原码(符号位不变,其他位取反) 10000000 00000000 00000000 00000011 * 7. 转换为十进制的值为 -3 * */ System.out.println(~2); } } 运算符 描述 >> 算数右移 低位溢出,符号位不变,并用符号位补溢出的高位 > 无符号右移、逻辑右移 低位溢出,高位补0 public class TernaryOperatorDetail { public static void main(String[] args) { /* 计算 (15 >> 2) * 1. 先得到1的原码 00000000 00000000 00000000 00001111 * 2. 低位溢出,符号位不变,并用符号位补溢出的高位 * 3. 得到 00000000 00000000 00000000 00000011 * 4. 转换为十进制是3 * 5. 本质是 15 / 2 / 2 = 3 * */ System.out.println(1 >> 2); /* 计算 (4 >运算符会用 0 填充高位,这与>>不同,它会用符号位填充高位。不存在> 从左向右 < >= instanceof 从左向右 == != 从左向右 & 从左向右 ^ 从左向右 丨 从左向右 && 从左向右 丨丨 从左向右 ? : 从左向右 = += -= *= /= %= &= 丨= ^= = >>>= 从右向左


【本文地址】

公司简介

联系我们

今日新闻

    推荐新闻

    专题文章
      CopyRight 2018-2019 实验室设备网 版权所有