【JAVA】第三章 JAVA运算

第三章 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变成0

public 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，其他的&为0

public 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);
	}
}