编程入门：掌握Java运算符技巧
作者：Y423x
掌握Java运算符技巧,能让你的编程之旅轻松许多,本指南将带你深入了解如何巧妙地使用这些强大的工具,让代码不仅高效,还充满乐趣,跟着我们一起,让你的Java代码在运算符的魔法下焕发新生！
运算符和表达式
int a = 10; int b = 20; int c = a + b;
+：是运算符，并且是算术运算符
a + b:是表达式，由于+是算术运算符，所以这个表达式叫算术表达式
算术运算符
符号
| 符号 | 作用 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取模、取余 |
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//+
System.out.println(3 + 2);//5
//-
System.out.println(5 - 1);//4
//*
System.out.println(7 * 9);//63
//如果在运算的时候有小数参与
//结论：
//在代码中，如果有效数参与，结果有可能不精确的。
System.out.println(1.1 + 1.1);//2.2
System.out.println(1.1 + 1.01);//2.1100000000000003
//除法
//结论：
//1.整数参与计算，结果只能得到整数
//2.小数参与计算，结果有可能是不精确的
System.out.println(10 / 2);//5
System.out.println(10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335
//取模、取余。实际上也是做除法运算，只不过得到的是余数而已。
System.out.println(10 % 2);//0
System.out.println(10 % 3);//1
//应用场景：
//1.可以用取模判断，A是否可以被B整除
//A % B 10 % 3
//2.可以判断A是否为偶数
//A % 2 如果结果为0，那么证明A是一个偶数。如果结果为1，那么证明A是一个奇数
//3.斗地主发牌
//三个玩家
//把每一张牌都定义一个序号
//拿着序号 % 3 如果结果为1，就发给第一个玩家
//如果结果为2，那么就发给第二个玩家
//如果结果为0，那么就发给第三个玩家
}
}
练习--数值拆分
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
公式总结：
- 个位：数值 % 10
- 十位：数值 / 10 % 10
- 百位：数值 / 100 % 10
- 千位：数值 / 1000 % 10
- ...
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
//1.键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();
//2.获取个位，十位，百位
//公式：
//个位： 数字 % 10
//十位： 数字 / 10 % 10
//百位： 数字 / 10 / 10 % 10
//...
int ge = number % 10;
int shi = number / 10 % 10;
int bai = number / 100 % 10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);
}
}
数字相加
数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算。
类型转换的分类
隐式转换（自动类型提升）
取值范围小的数值-->取值范围大的数值
//范例： int a = 10; double b = a;//b = 10.0
取值范围：double>float>long>int>short>byte
隐式转换的两种提升规则
取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算
byte、short、char 三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算
public class Test { public static void main(String[] args) { int a = 10;//取值范围小 double b = 12.3;//取值范围大 double c = a + b;//+ 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算 } }public class Test { public static void main(String[] args) { byte a = 10; byte b = 20; int c = a + b;//byte、short、char 三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算 } }
强制转换
取值范围大的数值-->取值范围小的数值（如果把一个取值范围大的数值，赋值给取值范围小的变量。是不允许直接赋值的。如果一定要这么做就需要加入强制转换）
格式：目标数据类型 变量名 = （目标数据类型） 被强转的数据；
//范例： double a = 12.3; int b = (int) a;
//范例： int a = 300; byte b = (byte) a;//会出现错误，byte的取值范围是-128~127，300超出取值范围
//范例： public class ArithmeticoperatorDemo2 { public static void main(String[] args) { byte b1 = 10; byte b2 = 20; //现在要强转的是b1 + b2计算之后的结果。 //（byte)b1 + b2 强转的是b1，并不是最终的结果 byte result = (byte) b1 + b2;//错误 byte result = (byte) (b1 + b2);//正确 System.out.println(result);//30 } }
字符串相加
字符串的“+”操作
当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算符了。
会将前后的数据进行拼接，并产生一个新的字符串。
"123" + 123//结果是"123123"
连续进行“+”操作时，从左到右逐个执行。
1 + 99 +"世界"//结果是"100世界"
//范例： int age = 18; System.out.println("刚满" + age + "岁");//"刚满18岁" System.out.println("刚满" + "age" + "岁");//"刚满age岁"//范例： System.out.println(1 + 2 + "abc" + 2 + 1);//"3abc21"
练习：数值拆分
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
//1.键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();
//2.获取个位，十位，百位
//公式：
//个位： 数字 % 10
//十位： 数字 / 10 % 10
//百位： 数字 / 10 / 10 % 10
//...
int ge = number % 10;
int shi = number / 10 % 10;
int bai = number / 100 % 10;
System.out.println("个位是" + ge);
System.out.println("十位是" + shi);
System.out.println("百位是" + bai);
}
}
字符相加
当 字符 + 字符 或 字符 + 数字 时，会把字符通过ASCLL码表查询到对应的数字再进行计算。
//范例： System.out.println(1 + 'a');//98 System.out.println('a' + "abc");//"aabc"
自增自减运算符
基本用法
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 加 | 变量的值加1 |
| -- | 减 | 变量的值减1 |
注意事项：++和--既可以放在变量的前面，也可以放在变量的后面
int a = 10; a++;//(++a;)后加加(先加加),表示将变量里面得值加1 System.out.println(a);//11
单独使用（用法一）：++和--无论是放在变量的前边还是后边，单独写一行结果都是一样的。
//范例： public class ArithmeticoperatorDemo3 { public static void main(String[] args) { //++ 和 -- int a = 10; //表示把变量a里面的值+1 a++; System.out.println(a);//11 //表示把变量a里面的值+1 ++a; System.out.println(a);//12 //表示把变量a里面的值-1 a--; System.out.println(a);//11 //表示把变量a里面的值-1 --a; System.out.println(a);//10 } }
应用场景一：
一岁-->生日后-->两岁
int age = 1; age++; System.out.println(age);
应用场景二：
购买物品增减购买数量时
| - | 2 | + |
|---|
应用场景三：数￥号
| ￥ | & | ￥ | & | ￥ |
|---|---|---|---|---|
| ++ | ++ | ++ |
参与计算（用法二）：
先用后加
int a = 10; int b = a++;//a=11,b=10
先加后用
int a = 10; int b = ++a;//a=11,b=11
练习
public class ArithmeticoperatorDemo4 {
public static void main(String[] args) {
int x = 10;
//后++：先用后加
int y = x++;
//先++：先加后用
int z = ++x;
System.out.println("x:" + x);//12
System.out.println("y:" + y);//10
System.out.println("z:" + z);//12
}
}
赋值运算符
分类
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | int a = 10,将10赋值给变量a |
| += | 加后赋值 | a+ = b,将a+b的值给a |
| -= | 减后赋值 | a -= b,将a-b的值给a |
| *= | 乘后赋值 | a *= b,将a×b的值给a |
| /= | 除后赋值 | a /= b,将a÷b的商给a |
| %= | 取余后赋值 | a %=b,将a÷b的余数给a |
注意事项：+=，-=，*=，/=，%= 底层都隐藏了一个强制类型转换
//范例：
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//+=
//规则：将左边和右边进行相加，然后再把结果赋值给左边
int a = 10;
int b = 20;
a += b;//等同于 a = (int) (a + b);
System.out.println(a);
System.out.println(b);
//细节：
//+=，-=，*=，/=，%= 底层都隐藏了一个强制类型转换
short s = 1;
s += 1;//等同于：s = (short) (s + 1);
System.out.println(s);//2
}
}
关系运算符
（关系运算符/比较运算符）的分类
| 符号 | 说明 |
|---|---|
| == | a==b,判断a和b的值是否相等，成立为true,不成立为false |
| != | a!=b,判断a和b的值是否不相等，成立为true,不成立为false |
|a>b,判断a是否大于b，成立为true,不成立为false
=|a>=b,判断a是否大于等于b，成立为true,不成立为false
<|a<b,判断a是否小于b，成立为true,不成立为false
<=|a<=b,判断a是否小于等于b,成立为true,不成立为false
注意事项：
- 关系运算符的结果都是boolean类型，要么是true,要么是false。
- 千万不要把“==”误写成“=”。
//范例：
public class CompareoperatorDemo1 {
public static void main(String[] args) {
//== 判断左右两边是否相等
int a = 10;
int b = 10;
int c = 20;
System.out.println(a == b);//true
System.out.println(a == c);//false
}
}
练习--约会
需求：
您和您的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入0~10之间的整数，不能录其他）
如果你的时髦程度大于你对象的时髦程度，相亲就成功，输出true。
否则输出false。
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
/* 需求：
您和您的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入0~10之间的整数，不能录其他）
如果你的时髦程度大于你对象的时髦程度，相亲就成功，输出true。
否则输出false。*/
//1.键盘录入两个整数表示衣服的时髦度
Scanner sc = new Scanner(System.in);
System.out.println("请输入我们自己的衣服时髦度");
int myFashion = sc.nextInt();
System.out.println("请输入相亲对象衣服的时髦度");
int girlFashion = sc.nextInt();
//2.把我衣服的时髦度跟女孩的时髦度进行对比
boolean result = myFashion > girlFashion;
//3.打印结果
System.out.println(result);
}
}
逻辑运算符
- 在数学中，一个数据x，大于5，小于15，表示成：5<x<15。
- 在Java中，需要把上面的式子先进行拆解，在进行合并表达。
- 拆解为：x>5 和 x<15
- 合并后：x>5 & x<15（&：并且）
分类
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑（且） | 并且，两边都为真，结果才是真（两边都要满足） |
| | | 逻辑或 | 或者，两边都为假，结果才是假（两边满足一个） |
| ^ | 逻辑异或 | 相同为false，不同为true |
| ! | 逻辑非 | 取反 |
//范例"&""|""：
public class LogicoperatorDemo1 {
public static void main(String[] args) {
//1. & 并且
//两边都为真，结果才是真
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
//2. | 或者
//两边都为假，结果才是假
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true
}
}
使用场景一
输入用户名和密码时，成功登陆的条件是：
用户名正确 并且 密码正确
使用场景二
结婚时女方要求要有
房子 或者 车子；（房子 并且 车子）
//范例"^""!"：
public class LogicoperatorDemo2 {
public static void main(String[] args) {
// ^ 异或
//相同为false，不同为true
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
// ! 逻辑非 取反
//提示：
//取反的感叹号不要写多次，要么不写，要么只写一次
System.out.println(!false);//true
System.out.println(!true);//false
}
}
短路逻辑运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 结果和&相同，但是有短路效果 |
| || | 短路或 | 结果和|相同，但是有短路效果 |
//范例：
public class LogicoperatorDemo3 {
public static void main(String[] args) {
//1.&&
//运行结果跟单个&是一样的
//表示两边都为真，结果才是真
System.out.println(true && true);//true
System.out.println(false && false);//false
System.out.println(false && true);//false
System.out.println(true && false);//false
//2.||
//运行结果跟单个|是一样的
//表示两边都为假，结果才是假
System.out.println(true || true);//true
System.out.println(false || false);//false
System.out.println(false || true);//true
System.out.println(true || false);//true
//3.短路逻辑运算符具有短路效果
//简单理解：当左边的表达式能确定最终的结果，那么右边就不会参与运行了
int a = 10;
int b = 10;
boolean result = ++a < 5 && ++b < 5;
System.out.println(result);//false
System.out.println(a);//11
System.out.println(b);//10
}
}
注意事项：
&|，无论左边 true false,右边都要执行。
&&||，如果左边能确定整个表达式的结果，右边不执行。
&&：左边为false，右边不管是真是假，整个表达式的结果一定是false。
||：左边为true，右边不管是真是假，整个表达式的结果一定是true。
这两种情况下，右边不执行，提高了效率。
最常用的逻辑运算符：&&，||，!
练习--数字6
需求：
数字6是一个真正伟大的数字，键盘录入两个整数。
如果其中一个为6，最终结果输出true。
如果他们的和为6的倍数。最终结果输出true。
其他情况都是false。
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
/*数字6是一个真正伟大的数字，键盘录入两个整数。
如果其中一个为6，最终结果输出true。
如果他们的和为6的倍数。最终结果输出true。
其他情况都是false。*/
//分析：
//1.键盘录入两个整数
// 变量a 变量b
//2.a == 6 || b == 6 || (a + b) % 6 = 0
//如果满足其中一个，那么就可以输出true
//键盘录入两个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number1 = sc.nextInt();
System.out.println("请输入第二个整数");
int number2 = sc.nextInt();
//用短路逻辑运算符去链接三个判断
boolean result = number1 == 6 || number2 == 6 || (number1 + number2) % 6 == 0;
System.out.println(result);
}
}
三元运算符
三元运算符
需求：定义一个变量记录两个整数的较大值。
int number = 拿着两个整数进行比较 System.out.println(number);
作用：可以进行判断，根据判断结果得到不同的内容
格式（三元运算符/三元表达式）
格式：关系表达式 ? 表达式1 : 表达式2；
范例：求两个数的较大值。
int max = a > b ? a : b;//把三元运算符的结果赋值给一个变量 System.out.println(a > b ? a : b);//把三元运算符的结果直接打印
//范例：
public class TernaryoperatorDemo1 {
public static void main(String[] args) {
//需求：使用三元运算符，获取两个数的较大值
//分析：
//1.定义两个变量记录两个整数
int number1 = 10;
int number2 = 20;
//2.使用千元运算符获取两个整数的较大值
//格式：关系表达式 ? 表达式1 : 表达式2；
//整个三元运算符的结果必须要使用
int max = number1 > number2 ? number1 : number2;
System.out.println(max);
System.out.println(number1 > number2 ? number1 : number2);
}
}
- 计算规则
- 首先计算关系表达式的值
- 如果值为true，表达式1的值就是运算结果
- 如果值为false，表达式2的值就是运算结果
练习1--两只老虎
需求：
动物园里有两只老虎，体重分别通过键盘录入获得，
请用程序实现判断两只老虎的体重是否相同。
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
/*需求：动物园里有两只老虎，体重分别通过键盘录入获得，
请用程序实现判断两只老虎的体重是否相同。*/
//分析：
//1.键盘录入两只老虎的体重
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一纸老虎的体重");
int weight1 = sc.nextInt();
System.out.println("请输入第二纸老虎的体重");
int weight2 = sc.nextInt();
//2.比较
//相同 不同
String result = weight1 == weight2 ? "相同" : "不同";
System.out.println(result);
}
}
练习2--求最高身高的和尚
需求：
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高。
public class Test5 {
public static void main(String[] args) {
/*需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高。*/
//1.定义三个变量记录三个和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;
//2.拿着第一个和尚和第二个和尚进行比较
//再拿着结果跟第三个和尚进行比较即可
int temp = height1 > height2 ? height1 : height2;
int max = temp > height3 ? temp : height3;
System.out.println(max);
}
}
运算符优先级
| 优先级 | 运算符 |
|---|---|
| 1 | .(){} |
| 2 | !、-、++、-- |
| 3 | *、/、% |
| 4 | +、- |
| 5 | <<、>>、>>> |
| 6 | <、<=、>、>=、instanceof |
| 7 | ==、!= |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ? : |
| 14 | =、+=、-=、*=、/=、%=、&= |
到此这篇关于编程入门：掌握Java运算符技巧的文章就介绍到这了,更多相关Java运算符内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！