- 第三章 JAVA 运算
- 3.1 运算符
- 3.1.1 概述
- 3.1.2 算术运算符
- 3.1.3 赋值运算符
- 3.1.4 比较(关系)运算符
- 3.1.5 逻辑运算符
- &，&& 和|，|| 的异同
- 3.1.6 三元运算(三目运算)
- 3.1.7 位运算
- 1. 位运算的概念
- 2. 按位非-- ~
- 3. 按位与-- &
- 4. 按位或-- |
- 5. 按位异或-- ^
- 6. 按位左移-- <<
- 7. 按位右移-- >>
- 3.2 键盘录入之Scanner类
- 3.2.1 Scanner类
- 3.2.2 Scanner类使用步骤：
- 3.3 随机数
- 3.3.1 Random类
- 1. Random类概述
- 2. Random类使用步骤：
- 3.3.2 UUID类
第三章 JAVA 运算
3.1 运算符
3.1.1 概述
1. 运算符概念：对常量或者变量进行操作的符号，通常用于数据的比较或运算。
2. 举例：
10 + 20 = 30 中，+ 是运算符中的算术符。
3. 运算符分类：
算术运算符，赋值运算符，比较运算符，逻辑运算符，位移运算符，三元运算符。3.1.2 算术运算符
1. 表达式：由常量，变量，运算符组成的符合java语法的式子就称为表达式，表达式都有结果，结果就是表达式的值。public class Test {
public static void main(String[] args) {
int a = 20;
int b = 8;
//操作符+
System.out.println("a+b=" + (a + b));
//操作符－
System.out.println("a-b=" + (a - b));
//操作符*
System.out.println("a*b=" + (a * b));
//操作符/
System.out.println("a/b=" + (a / b)); //两整数相除，结果只保留整数
//操作符%,只有整数可以取余运算
System.out.println("a%b=" + (a % b));
//自增自减，操作符在前，先使用再操作；操作符在后，先操作再使用
//操作符++
System.out.println("a++:" + (a++)); //++在后，先用后+
System.out.println("++a:" + (++a)); //++在前，先+后用
a = 20;
b = 8;
//操作符--
System.out.println("a--:" + (a--)); //--在后，先用后-
System.out.println("--a:" + (--a)); //--在前，先-后用
}
}
3.1.3 赋值运算符
public class Test {
public static void main(String[] args) {
//=
int a = 20;
int b = 8;
//操作符+=
System.out.println("a+=b:" + (a += b));
a = 20;
b = 8;
//操作符-=
System.out.println("a-=b:" + (a -= b));
a = 20;
b = 8;
//操作符*=
System.out.println("a*=b:" + (a *= b));
a = 20;
b = 8;
//操作符/=
System.out.println("a/=b:" + (a /= b));
a = 20;
b = 8;
//操作符%=
System.out.println("a%=b:" + (a %= b));
a = 20;
b = 8;
}
}
3.1.4 比较(关系)运算符
- 比较运算符是用于比较是否相等和关系大小的符号，计算结果为布尔值，true或者false。
1. 关系运算符就是对两个变量存储的数值大小进行比较，是一个二元操作符（有两个参数）
2. 比较运算符只有两种boolean类型的值，true和false
3. equals() 比较两数内存中的值是否相等
4. == 比较两个值内存地址是否相同public class Test {
public static void main(String[] args) {
int a = 10;
int b= 30;
//==
System.out.println("a==b?"+(a==b));
//!=
System.out.println("a!=b?"+(a!=b));
//>
System.out.println("a>b?"+(a>b));
//<
System.out.println("a<b?"+(a==b));
//>=
System.out.println("a>=b?"+(a>=b));
//<=
System.out.println("a<=b?"+(a<=b));
}
}
3.1.5 逻辑运算符
用于连接两个boolean类型（逻辑）数据的运算符，只能运算boolean类型的数据，运算结果为boolean类型。
public class Test {
public static void main(String[] args) {
boolean a = true;
boolean b = true;
boolean c = false;
boolean d = false;
// %与，全真为真,一假则假
System.out.println("true & true :"+(a&b));
System.out.println("true & false :"+(a&c));
//| 或，有真为真，全假才假
System.out.println("true | false :"+(a|c));
System.out.println("false | false :"+(d|c));
//^ 异或，全真为真，全假为假
System.out.println("true ^ true :"+(a^b));
System.out.println("false ^ false :"+(d^c));
//! f非，就是取反
System.out.println("!a:"+(!a));
System.out.println("!c:"+(!c));
int x = 3;
int y = 4;
//&& 短路逻辑与，全真为真,一假则假，当左边为假就不计算到右边了，短路
System.out.println((x>y)&&(x<y));
System.out.println((x<y)&&(x>y));
//|| 短路逻辑或，有真为真，全假才假，当右边判断为真时不计算右边，认为就是真的
System.out.println((x>y)||(x>y));
System.out.println((x<y)||(x>y));
}
}
&，&& 和|，|| 的异同
1.&&和&相同点：
&是逻辑与，&&短路与。两个执行最终结果相同，表达式左右只要有一个为false 结果为false。
2. &&和&不同点：
如果表达左边已经为false && 右边就不执行了。
3.|和||相同点：
|是逻辑或，&&短路或。两个执行最终结果相同，表达式左右只要有一个为true 结果为true。
4.|和||不同点：
如果表达左边已经为true ||右边就不执行了。
- 口诀：
& 一假则假，全真为真
| 一真为真, 全假为假
! 结果取反
^ 相同为假, 不同为真3.1.6 三元运算(三目运算)
1. 别名：三目运算符，同时可以操作三个数据或者表达式的运算符
2. 格式：表达式？值：值；------取值：左真右假。
表达式是布尔类型表达式
3. 使用三目运算的优点：节省代码class S0305 {
public static void main(String[] args){
//案例1:小明考试成绩如果>=60输出合格，<60输出不及格
int score = 59;
//普通方法：两个if判断
if(score >= 60){
System.out.println("小明考试及格");
}
if(score < 60){
System.out.println("小明考试不及格");
}
//使用三元/三目运算 值类型任意
//左边表达式true or false ，如果返回true 取:左边的值，如果返回false 取:右
//左真右假
System.out.println(score >= 60?"小明考试及格":"小明考试不及格");
//案例2： 定义int i = 0 or 1 如果为0打印false 如果为1 打印true
//mybatis -- insert into 表名 (列名) value (值) -- 数值类型 01234678
//0 表示受影响行数为0 操作失败 1 就是表示成功了！！！
int i = 1;
System.out.println(i == 0?false:true);
}
}3.1.7 位运算
1. 位运算的概念
1. 位运算：就是对二进制数据进行数字操作的一些规则
2. 位运算在对源码进行分析或者自己研发工具时会大量使用到，比如HashMap源码中就涉及到位运算
3. 位运算的优势：直接对计算机中的二进制数据进行操作，速度快效率高
4. 位运算分为：
（1）按位非-- ~
（2）按位与-- &
（3）按位或-- |
（4）按位异或-- ^
（5）按位左移-- <<
（6）按位右移-- >>
（7）无符号按位右移-- >>>
5. 注意：除了按位非~ 是操作一个二进制数的，其他按位运算都是操作两个二进制数，故都叫二运操作符2. 按位非-- ~
按位非-- ~：
将二进制数每一位(包括符号位)都取反：0变成1,1变成0public class Test {
public static void main(String[] args) {
byte num = 10; //10二进制:00001010
byte num1 = ~num ; // //按位非~：==>二进制:10001011
System.out.println(num1); //-11
}
}
3. 按位与-- &
按位与-- &:
将参与运算的两个数的二进制进行&运算，都为1，&为1，其他的&为0public class Test {
public static void main(String[] args) {
byte num1 = 10; //10二进制: 00001010
byte num2 = 11 ; //11二进制:00001011
System.out.println(num1&num2); //按位& ：00001010 ==》10
}
}
4. 按位或-- |
按位或-- |:
将参与运算的两个数的二进制进行|运算，都为0，|为0，其他的|为1
（1）两参数为一正一负时运算结果是负数
（2）两参数均为整数或者均为负数时，运算结果都是正数public class Test {
public static void main(String[] args) {
byte num1 = 10; //10二进制: 00001010
byte num2 = 11 ; //11二进制:00001011
System.out.println(num1|num2); //按位| ：000001011 ==》11
}
}
5. 按位异或-- ^
按位异或-- ^:
对应位上数据相同返回0，数据不同返回1
（1）两参数为一正一负时运算结果是负数
（2）两参数均为整数或者均为负数时，运算结果都是正数public class Test {
public static void main(String[] args) {
byte num1 = 10; //10二进制: 00001010
byte num2 = 11 ; //11二进制:00001011
System.out.println(num1^num2); //按位^：00000001 ==》1
}
}6. 按位左移-- <<
1. 按位左移-- <<： 二进制位上的数据统一向左移动指定位数，高位（不包括符号位）移除，地位补0，符号位不变
2. 左移超出对应类型最大值或者最小值就截断（丢弃）符号位，使用左移后的最高位作为符号位，数据的符号位可能会改变，否则符号位不变
3. 若是byte(8位)或者short（16位），会自动扩大类型为int类型（32位）
4. 若运算数是int类型：每移动1位，第31位就要被移除丢弃（左移后的数据不超过int类型的最大值和最小值）
5. 若运算数是long类型：每移动1位，第63位就要被移除丢弃（左移后的数据不超过long类型的最大值和最小值）//1. 左移未超过数据类型最大值与最小值
int num1 = 10; //10二进制: 0000000000001010
System.out.println(num1<<3); //按位左移3位：0000000001010000==> 10*2^3=80
//2. 左移超过数据类型最大值与最小值，符号位可能会改变
int num2 = 10; //10二进制: 0000000000001010
System.out.println(num1<<28); //按位左移28位：0000000001010000==> 10*2^3=80
//2. 计算5*8的最快方法：5*2^3.就是5左移3位
int n = 5;
int m = n<<3;
System.out.println("5*8="+m);
}
}
7. 按位右移-- >>
分为带符号按位右移和无符号右移
1. 带符号按位右移-- >>： 二进制位上的数据统一向右移动指定位数，低位丢弃，符号位不变（不参与移动）
2. 带符号按位右移-- >>： 二进制位上的数据统一向右移动指定位数，低位溢出，高位补0，符号位跟着移动public class Test {
public static void main(String[] args) {
//带符号按位右移
int num1 = 10; //10二进制: 0000000000001010
System.out.println(num1>>1); //带符号按位右移1位：0000000000000101==>5
//无符号按位右移
int num2 = 10; //10二进制: 0000000000001010
System.out.println(num1>>>2); //无符号按位右移1位：0000000000000010==>2
}
}
3.2 键盘录入之Scanner类
3.2.1 Scanner类
1. 键盘输入：Scanner类，来自java.util包，是JDK提供的类型。
2. 作用：在程序运行中，可以使用Scanner类来获取从键盘输入的数据，提高数据来源灵活度。3.2.2 Scanner类使用步骤：
1.导包, ---目的：让JDK定位到Scanner类型所在的具体位置。
import java.util.Scanner;
2. 创建键盘录入对象，如
Scanner sc = new Scanner(System.in);
3.调用sc对象的nextInt()方法，获取键盘录入的一个整数
int x = sc.nextInt();
4.使用x//1.导包
//* 通配符，表示将util包下的所有类都引入到当前类
//import java.util.*;
import java.util.Scanner;
public class Test {
/**
* 键盘录入两整数求和
* @param args
*/
public static void main(String[] args) {
//2.new实例化对象，在堆中开辟内存空间
//scanner一个引用，引用存在栈中,sc 是引用名，实例对象名
//System.in 读取输入流信息
Scanner sc = new Scanner(System.in);
System.out.println("请输入第1个数：");
//3.捕获/接收控制台输入的信息 .next()表示接收任意类型数据
int a = sc.nextInt();
System.out.println("请输入第2个数：");
int b = sc.nextInt();
//输出两数和
System.out.println("两数之和为："+(a+b));
}
}- 案例：2 键盘录入三整数求最大值
- 键盘录入一整数,判断奇偶
import java.util.Scanner; 2 class S0307 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//录入三个整数
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
//定义一个max
int max = 0;
//先比较两数，取得max
max = a > b ? a : b;
//通过max和c再做比较,三目运算更加简洁。
max = max > c ? max : c;
System.out.println(max);
//键盘录入一整数,判断奇偶
int x = sc.nextInt();
System.out.println(x % 2 == 0?"偶数":"奇数");
}
}
3.3 随机数
3.3.1 Random类
1. Random类概述
1. JDK提供了一个类, 类名Random, 主要功能 : 可以生成**指定范围内**的任意一个随机数
2. Random来自于java.util路径下2. Random类使用步骤：
1. 导包 - import java.util.Random;
2. 创建Random类对象:Random ran = new Random();
3.使用ran对象名，调用功能方法
int i = nextInt(int count)；--> 参数count表示需要随机生成的数据的范围(0~count-1), 此方法生成数据范围
注意 : 生成的随机数, 可以使用一个变量将其结果保存下来
4.后续随机数使用。//1.导包
import java.util.Random;
public class Test {
/**
* 案例 :,打印出10个 1-100之间的任意一个随机整数
* @param args
*/
public static void main(String[] args) {
//1. new创建Random类对象
Random ran = new Random();
// 2. 获取到1-100之间任意一个随机数
for(int i=0;i<10;i++){
int number = ran.nextInt(100) + 1;// (0-99) + 1
System.out.print(number+"\t");
}
}
}3.3.2 UUID类
1. UUID（随机ID生成类）相当于封装处理了Random 类，主要用于给数据库表指定主键的时候使用的非常多。
2. UUID类使用
(10)导包：
import java.util.UUID;
(2)调用UUID类中的.randomUUID()方法：
UUID u = UUID.randomUUID();
随机ID生成类.类中的静态（static）方法是可以通过类名.方法名（）；直接调用的。
(3)后续使用。import java.util.UUID; 2 class S0309 {
public static void main(String[] args) {
//随机ID生成类.类中的静态方法是可以通过类名.方法名直接调用的。
UUID u = UUID.randomUUID();
System.out.println(u);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
