day03
- 运算符
运算符: 进行运算,逻辑业务处理的符号
1.1 算数运算符
1.1.1 基本算数运算符:
-
-
- / %
-
-
:
- 单独作用在数据之前,表示这个数据时一个正数,举例: +3
- 进行数值之间的加法 举例: 3 + 2 = 5
- 字符串的加法,字符串与任意的数据类型相加,表示拼接,相当于在字符串的末尾进行追加,
结果任然是一个字符串类型
- :
- 单独作用在数据之前,表示负数 举例 : -3
- 进行数值之间的减法 举例 : 3-2 = 1
- :
- 进行数值之间的相乘
/ :
- 进行两数的相除
a : 如果两个数值都是整数,相除的结果也是整数,如果没有除尽,那么小数全部舍掉
b: 如果两个数中,有一个是浮点类型,那么相除的结果就是浮点类型
% : 叫做取模运算,获取两数相除得到的余数
取模运算符的使用场景: 其实多数情况下做数据筛选
- 取模的结果是有正负的,根据%符号,前面的数据符号决定结果符号
举例: -7 % 2 = -1
7 % -2 = 1
要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
分析: 偶数可以被2整除,奇数不能被2整数
如果数值与2进行取模,结果为0,那么这个数就是一个偶数
x % 2 == 0------> x就是个偶数
x % 2 == 1------> x就是一个奇数
代码
// 基本算数运算符
public class SuanShuYuanSuan {
public static void main(String[] args) {
// 1. +
System.out.println(3);
// 1) 作用在数据之前,表示这个数据时一个正数
System.out.println(+3);
// 2) 两个常量数值相加
System.out.println(5+10);
// 两个变量相加
int x = 8 ;
int y = 9 ;
System.out.println(x + y);
// 3) 字符串与任意的数据类型相加,表示拼接
String s = “5”;
String s1 = s + y ;// 59
System.out.println(s);
System.out.println(s1);
System.out.println("-------------------");
// 2. -
// 1) 作用在数据之前,表示这个数据时一个负数
System.out.println(-3);
// 2) 两个常量数值相加
System.out.println(5-10);
// 3. *
System.out.println(x*y);// 8*9 = 72
// 4. /
// 1) 两个整数类型相除,小数点全部舍掉
System.out.println(x/y);// 8/9 = 0
System.out.println(y/x);// 9/8 = 1
// 2) 带有浮点型数据的相除,结果是浮点类型(可以带小数的结果)
// 常量7.0 是double类型 常量2是int类型
System.out.println(7.0/2);// 3.5
System.out.println(7/2.0);// 3.5
System.out.println(7.0/-2.0);// -3.5
// 5. % 取模运算
System.out.println(x%y);// 8%9 = 8/9 = 0...8
System.out.println(y%x);// 9%8 = 9/8 = 1...1
// 取模运算的符号,与符号前面的数据符号保持一致
System.out.println(-7%2);// -1
System.out.println(7%-2);// 1
}
}
1.1.2 自增自减运算
++ : 自增,表示每次让变量的值加1
– : 自减,表示每次让变量的减1
自增和自减都作用在变量上
自增和自减运算符的使用:
- 如果变量不参与运算,那么++ 或者 – 写在变量前或者是写在变量后,结果是一致的,都是变量值本身+1
- 如果变量参与运算
a: ++ 或 – 写在变量之前,那么先进行变量本身的自增或者自减,然后再参与运算
b : ++ 或 – 写在变量之后,先进行运算,运算结束,在进行变量本身的自增或自减
代码
// 基本运算符中的自增和自减运算
public class AddOrSub {
public static void main(String[] args) {
// 1. 自增或自减的变量,不参与运算
int x = 10;
x ++ ; // 相当于 x = x + 1 ;
System.out.println(x);//11
++ x ; // 相当于 x = x + 1 ;
System.out.println(x);//12
// 2. 自增或自减的变量,参与运算
int y = 5 ;
int z = 10 ;
// 1) y值参与运算 2) --自减作用在变量之前,先进行变量的自减操作 y = 4
// 3) 再参与和Z的加法运算 y+z = 4 + 10 = 14
int w = --y + z ;
System.out.println(w);// 14
System.out.println(y);// 4
// 自增或自减作用在变量之后,变量参与运算
int a = 8 ;
int b = 9 ;
// 1) a的值参与运算 2) ++ 作用在a的变量之后,先进行a+b的运算 8+9 = 17
// 将17的值,赋值给变量c 3) a变量进行++ 自增,8------>9
int c = (a++) + b;
System.out.println(c);// 17
System.out.println(a);// 9
}
}
1.2赋值运算符
基本赋值运算符:
= : 表示将等号右边的数值,赋值给等号左边的变量
扩展的赋值运算符:
+= : 先进行等号右边加法的运算,将运算结果赋值给等号左边变量
举例: int x = 5;
x += 3; // 相当于 x = x +3 ----> 5+3=8----->x=8
-= : 先进行等号右边的减法运算,将运算结果赋值给等号左边变量
*=: 先进行等号右边的乘法运算,将运算结果赋值给等号左边变量
/=: 先进行等号右边的除法运算,将运算结果赋值给等号左边变量
%=: 先进行等号右边的取模运算,将运算结果赋值给等号左边变量
代码
// 赋值运算符
public class FuZhiYunSuan{
public static void main(String[] args) {
// 1. =
int i = 9 ; // i 变量所表示的值就是9
System.out.println(i+2);// 11
// 2. +=
// 1) i += 3; 相当于 i = i + 3 ; 2) 先计算i+3 = 9 + 3 = 12
// 3) 将计算结果赋值给变量i , i = 12;
i += 3;
System.out.println(i);//12
// 3. *=
i *= 2;// i = i * 2; 12 * 2 = 24 = i
System.out.println(i);// 24
}
}
1.3比较运算符
主要进行数值的结果的比较,比较运算符的结果是布尔类型 boolean,结果只有true,false
== : 表示,判断符号两边的数值是否相等,相等返回true,不相等返回false
!= : 表示不等于,判断符号两边的数值是否不相等,不相等返回true,相等返回false
: 判断符号左边的数值是否大于符号右边的数值,大于返回true,不大于返回false
=: 判断符号左边的数值是否大于等于符号右边的数值,大于等于返回true,否则返回false
<:判断符号左边的数值是否小于符号右边的数值,小于返回true,不小于返回false
<= :判断符号左边的数值是否大于等于符号右边的数值,小于等于返回true,否则返回false
注意: 比较运算符的使用,不能做连续的比较
代码
// 比较运算符
public class BiJiaoYunSuan{
public static void main(String[] args) {
int x = 9 ;
int y = 8 ;
// 1. ==
boolean boo = x == y ;// 8 == 9 ? 不相等,返回就是false
System.out.println(boo);// false
// 2. !=
boolean boo1 = x != y ;// 8 != 9 ? 不相等,返回就是true
System.out.println(boo1);// true
// 3. >
boolean boo2 = x > y ;
System.out.println(boo2);
boolean boo3 = x >= y ;
System.out.println(boo3);
// 4. <
boolean boo4 = x < y ;// 9 < 8
System.out.println(boo4);
boolean boo5 = x <= y ;// 9 <= 8
System.out.println(boo5);
// 要求: 给出一个数值,判断一下,这个数,是不是大于等于5,同时小于等于10
// 注意: 比较运算符的使用,不能做连续的比较
// 实际开发: 5 <= w 并且 w <= 10
int w = 7;
// 1) 5 <= w -----> true <= 10-----> 类型比较错误
// boolean boo6 = 5 <= w <= 10 ; 错误代码,
// System.out.println(boo6);
}
}
1.4逻辑运算符
可以进行逻辑运算的符号,称为逻辑运算符,结果是boolean类型
例如: 有一个登录的界面,需要客户输入用户名,输入一个密码,客户如何能成功登录
客户所输入的用户名正确 并且 客户输入的密码正确 ,才能登录成功
- & : 与,和,并且,符号两边都需要是boolean类型的表达式,只有符号两边的表达式都为true,那么&的结果才为true,否则结果就是false
true&true true
true&false false
false&true false
false&false false
&& : 短路与, 与&的结果完全一致,实际开发中,&&的使用率是绝对高
&& 在进行逻辑运算的时候,效率高
效率高的原因: 如果&&左边的表达式,为false,那么&&的结果其实已经确定为false,&&就直接返回false,不进行&&右边表达式的运算和判断
- | : 或者,符号两边的表达式都需要boolean类型,两个表达式中,只要有一个是true,那么或的返回值就是true
true | true true
true | false true
false | true true
false | false false
||: 短路或,与|结果,完全一致,短路或性能高,在实际开发中使用率高
效率高的原因: 如果|| 左边的表达式结果为true, 那么||的结果已经确定为true,所以就直接返回true, 右边表达式不管是什么,都不再进行判断和运行
举例: 需要客户输入电话号码,输入客户的手机或者是家庭座机
-
! : 表示取反,针对于boolean类型的表达式进行取反
!true false
!false true -
^ : 异或,表示符号两边的boolean类型表达式结果相同为false,不同为true
true^true false
false^false false
true ^ false true
false ^ true true
代码
// 逻辑运算符
public class LuoJiYunSuan{
public static void main(String[] args) {
// 要求: 给出一个数值,判断一下,这个数,是不是大于等于5,同时小于等于10
// & : 与逻辑运算
int w = 7;
boolean boo = w >= 5 & w <= 10 ;
System.out.println(boo);// true
// &&
// 1) 4 < 3 结果为false , 如果&&左边表达是为false,那么右边不运行,直接返回false
boolean boo1 = 4 < 3 && ++w >= 8 ;
System.out.println(boo1);// flase
System.out.println(w);// 7
// 2) & 运算,符号两边的表达式都会进行运算和判断
int q = 7 ;
boolean boo2 = 4 < 3 & ++q >= 8 ;
System.out.println(boo2);// flase
System.out.println(q);// 8
System.out.println("------------------");
// 或运算符
int a = 10 ;
int b = 20 ;
// false | true -----> true
boolean boo3 = a >= 20 | b >= 20 ;
System.out.println(boo3);// true
// 验证||效率高
boolean boo4 = b >= 20 | ++a >= 20 ;
System.out.println(boo4);// true
System.out.println(a);// 11
// 验证||效率高
int aa = 10;
boolean boo5 = b >= 20 || ++aa >= 20 ;
System.out.println(boo5);// true
System.out.println(aa);// 10
System.out.println("------------------");
// ! : 取反
System.out.println(!true);// false
System.out.println(!false);// true
// ^ : 相同为false,不同为true
boolean boo6 = true ^ false ;
System.out.println(boo6);// true
boolean boo7 = true ^ true ;
System.out.println(boo7);// false
}
}
1.5位移运算符(了解)
正常在进行数值的计算的场景: 如果需要乘2或者除2这种场景,可以使用位移运算
针对于2或者是2的倍数乘和除,位移运算速度快
<< : 左位移,能让数值乘以2,或者是乘以2的倍数
: 右位移,能让数值除2,或者是除2的倍数
一个整数,是十进制
10-----> 表示十进制的数值2
11-----> 表示十进制的数值3
100----> 表示十进制的数值4
<< : 表示将十进制数所对应的2进制,向左移动1位
000010000----> 16
: 表示将十进制数所对应的2进制,向右移动1位
00000010 —> 2
代码
// 位移运算
public class WeiYiYunSuan{
public static void main(String[] args) {
int w = 10 ;
// 表示将w所对应的2进制数,向左移动2位,变成原来值的4倍
int y = w << 2 ;
System.out.println(y);// 40
y = y >> 1 ;
System.out.println(y);// 20
}
}
1.6三元运算
三元运算又称三目运算
三元运算: 如果有两个选择,必须要选择出一个,这种场景可以使用三元运算
三元运算公式:
表达式1 ? 表达式2 : 表达式3 ;
解释:
- 表达式1, 必须是布尔boolean类型的表达式,结果 true 真, false 假
- ? : 问,表达式1的结果是真还是假
- 如果表达式1结果为true,那么只执行表达式2的内容
- 如果表达式1的结果为false,那么只执行表达式3的内容
- 表达式2和表达式3数据的结果可以任意,但是尽量要求大家让表达式2和表达式3数据类型结果一致
要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
代码
// 三元运算
public class SanYuanYunSuan{
public static void main(String[] args) {
//公式: 表达式1 ? 表达式2 : 表达式3 ;
// 1. 要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
int w = 70 ;
// w % 2 结果可能是1 也可能是0 ,通过==比较运算符,验证一下,w 和2 取模的
// 结果是否和0相等,如果和0相等,证明是偶数,否则是奇数
String s = w % 2 == 0 ? “这个数是一个偶数” : “这个数是一个奇数” ;
System.out.println(s);
// 2. 要求 : 给你任意一个整数,数是奇数,得到的结果是原值+1
// 数是偶数,得到的结果是原值-1
int t = w % 2 == 0 ? w-- : w++ ;
System.out.println(t);// 70
System.out.println(w);// 69
}
}
- 引用数据类型键盘输入和随机数
2.1 Scanner类键盘录入
Scanner 类 : 功能,就是可以接收键盘输入的数据,可以接收整数,可以接收字符串
Scanner类是JDK已经写好的一个类,存在于JDK的src.zip压缩包中,存在于java.util的文件夹下,Scanner 是一个引用数据类型
引用数据类型的功能实现过程:
-
导包: 导入所要使用的类它所在的路径
import : 关键字,功能就是进行类它所在的路径的导入
在导包时,文件夹之间使用英文 . 来进行分隔
import java.util.Scanner ; -
解释: 1) import java.util.Scanner ; 写在类上面
为什么需要import导包
通过import导入了Scanner类所在的具体的路径,在你自己的Java代码中,要使用Scanner的时候,可以通过import快速的确定Scanner的位置,将Scanner加载进内存运行,Scanner中功能才能被使用 -
创建一个Scanner对象
公式:
Scanner sc = new Scanner(System.in); -
调用Scanner中的功能: 接收键盘输入的数据
名字.方法();
sc.nextInt() ; -
Scanner 中的方法(功能)
- nextInt() : 表示接收键盘输入的整数
- next() : 表示接收键盘输入的字符串
键盘输入整数代码
// Scanner类接收键盘输入数据的使用
// 1. 先导入Scanner类的存在路径
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
// 2. 创建一个Scanner对象
// System.in -----> 系统输入----->System系统 in 输入
Scanner sc = new Scanner(System.in);
// 3. 通过变量名sc调用Scanner类中的方法(功能)
// nextInt() : 表示接收键盘输入的整数
System.out.println(“请输入一个整数”);
int x = sc.nextInt();
System.out.println(“我获取到了键盘输入的数据”+x);
// 要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
//1. 获取到一个键盘输入的任意的整数
System.out.println("请输入一个整数判断奇偶数:");
int w = sc.nextInt();
// 2. 判断这个数是奇数还是偶数
String ss = w % 2 == 0 ? "是一个偶数" : "是一个奇数" ;
System.out.println(ss);
}
}
键盘输入字符串代码
//接收键盘录入的字符串
// 1. 先导入Scanner类所在的路径
import java.util.Scanner;
public class ScannerDemo2{
public static void main(String[] args) {
// 2. 创建一个Scanner对象
Scanner sc = new Scanner(System.in);
// 3. 调用Scanner中的方法,接收键盘输入的字符串
// next()
System.out.println(“请输入一个字符串”);
String s = sc.next();
System.out.println("字符串 “+s + " 已经获取到”);
}
}
练习1:
接收键盘录入的任意两个整数,输出两个数中的较大数
代码
// 接收键盘录入的任意两个整数,输出两个数中的较大数
/*
分析: 1. 通过键盘,获取到2个数----> 获取一个整数 nextInt(),方法调用两次
2. 通过三元运算,判断出两个数中的较大数,输出到控制台
*/
// 1. 先导入Scanner类的所在路径
import java.util.Scanner;
public class ScannerMaxNumber{
public static void main(String[] args) {
// 2. 创建一个Scanner 对象
Scanner sc = new Scanner(System.in);
// 3. 获取到两个整数,使用nextInt() 方法
System.out.println(“请输入第一个整数:”);
int x = sc.nextInt();
System.out.println(“请输入第二个整数:”);
int y = sc.nextInt();
// 4. 输出一个较大的数
int result = x >= y ? x : y ;
System.out.println(“两个数中较大值为:”+result);
}
}
2.2 Random 类生成随机数(扩展)
Random 也是JDK写好的一个类,功能主要是生成随机数
来自于 java.util
如果要使用Random生成一个随机数,步骤如下:
- 先导包: import java.util.Random;
- 创建一个Random对象 : Random ran = new Random();
- 创建的类对象的名字.方法();
- Random 类功能:
nextInt() : 生成一个随机的int类型范围的整数
需求升级: 我需要生成指定范围内的随机整数nextInt(int类型数据)
举例: nextInt(5): 表示生成[0-5)之间的整数,包含0,不包含5
nextDouble() : 生成一个随机的小数,[0-1)
代码
// 生成随机数案例
// 1. 先导入Random类所在路径
import java.util.Random;
public class RandomDemo{
public static void main(String[] args) {
// 2. 创建一个Random对象
Random ran = new Random();
// 3. 使用ran对象名.调用方法
// nextInt() : 随机生成一个int类型的整数
int x = ran.nextInt();
System.out.println(x);
//4. nextInt(50): 表示生成的随机数的范围[0,50)
// 数据范围在0-50之间,包含0不包含50
int y = ran.nextInt(3);// 0-2
System.out.println(y);
// 5. 要求: 生成的数1-33之间
int w = ran.nextInt(33)+1;// 0-32 + 1 ----> 1-33
// 6. 生成一个小于1的随机小数
double d = ran.nextDouble();
System.out.println(d);
}
}