运算符的使用&数据读取语法

一、赋值运算符

1.一般格式为：变量 = 数值
2.数值的类型是变量类型的可接受类型（保持一致、满足类型转换）
3.等号两边都是变量的情况时：

int a = 10;
int b = 20;
a = b; // 表达的是将b的值赋值给a
System.out.println(a); // 20

等号左边取得是变量的内存空间，右边实质上取得是变量空间中存的一个具体值。

floor(天花板）	向上取整
ceil	向下取整
round	四舍五入

二、算术运算符

1.在除法中，选择的是向下取整的方法

int a = 2;
int b = 7;
int c = -1;
// 结果采用向下取整的方法
System.out.println(a/b); // 输出结果为：0
System.out.println(c/b); // 输出结果为：-1

2.自增/自减运算符

int a = 10;
// a++ 表达式的值是10，a随后变成11
// ++a 表达式的值是11，a随后变成11

如果不取自增运算的表达式的返回值，则前置自增和后置自增无区别；
如果取表达式的返回值，则前置自增的返回值是自增之后的值，后置自增的返回值就是当前的值

public static void main(String[] args) {
 int a = 10;
 // 10
 System.out.println(a++);
 // 11
 int b = 10;
 System.out.println(++b);
}

1. 关系运算符

这里的运算符和我们数学上学习的规则一致：==、!=、<、>、<=、>=

public static void main(String[] args) {
 // 返回值都是boolean
 int a = 10;
 int b = 20;
 System.out.println(a == b); //false
 System.out.println(a != b); //true
 System.out.println(a < b); //true
 System.out.println(a > b); //false
 System.out.println(a <= b); //true
 System.out.println(a >= b); //false
}

2. 逻辑运算符

1.&&、||、!= 的操作数的类型

p && true <=> p
p && false <=> false
p || true <=> ture
p || false <=> p
!!p <=> p

!(p && q) <=> !p || !q
!(p || q) <=> !p && !q
(p && q) && r <=> p && (q && r)
(p || q) || r <=> p || (q || r)
p && (q || r) <=> (p && q) || (p && r)
p || (q && r) <=> (p || q) && (p || r)
if(!(a >= 3 && a <= 10)) <=> if(a < 3 || a > 10)

2.短路原则

public static void main(String[] args) {
 int a = 10;
 if (a++ > 10 && a++ <100) {...}
 // a++值为10，所以第一个条件不满足，直接返回11
 System.out.println(a);
 
 int a = 10；
 if (a++ > 10 || a++ < 100) {...}
 // a++值为10，所以第一个条件不满足，对第二个条件进行判断
 // 此时第二个a++的值为11，两个条件都不满足，跳出循环，返回12
 System.out.println(a);
}

3.按位逻辑操作：& 逻辑与，| 逻辑或，无短路操作

3 & 5 —— 0b011 & 0b101 —— 0b001 = 1
3 | 5 —— 0b011 | 0b101 —— 0b111 = 7

4.按位取反：~

byte a = 5;
a —— 0b0000_0101
 ~a —— 0b1111_1010

p = ?;
// 把p最后一位set为0，其他位保持不变
(~1) & p;
// 把p最后一位set为1，其他位保持不变
1 | p;

5.异或 ^
相同为假，相异为真

3 ^ 7 —— 0b011 ^ 0b111 —— 0b100 = 4

6.&、| 的操作数都应该是 boolean 类型的

byte p = ?
p & 0xFF == p
p & 0x00 == 0x00
p | 0xFF == 0xFF
p | 0x00 == p
~0x00 == 0xFF
~0xFF == 0x00

3. 移位运算符

1.左移 <<：按二进制形式把所有的数字向左移动对应的位数，高位移出(舍弃)，低位的空位补零。
2.右移 >>：按二进制形式把所有的数字向右移动对应的位数，低位移出(舍弃)，高位的空位补符号位，即正数补零，负数补1。

3 —— 0b11 3 << 2 —— 0b1100
3 —— 0b11 3 >> 2 —— 0b1

p = ?;
// 把p的最后第m位（m从0开始）set为0，其他位保持不变
~(1 << m) & p;
// 把p的最后第m位（m从0开始）set为1，其他位保持不变
(1 << m) | p;

3.无符号右移 >>>
会将数值的所有 32 位都向右移。对于正数，无符号右移与有符号右移结果相同。
对于负数，差异会非常大。无符号右移会给空位补 0 ，而不管符号位是什么。无符号右移操作符将负数的二进制表示当成正数的二进制表示来处理。

let oldValue = -64; 
// 等于二进制 11111111111111111111111111000000
let newValue = oldValue >>> 5; 
// 等于十进制 134217726
在对- 64 无符号右移 5 位后，结果是00000111111111111111111111111110 ，即 134 217 726 。

4.条件运算符

表达式1 ? 表达式2 : 表达式3;

即三目运算符：当表达式1的值为true时，整个表达式的值为表达式2；当表达式1的值为false时，整个表达式的值为表达式3的值

三、读取输入

1.进行读取输入：next()
一次只能输入一个，若想多次输入，必须进行多个变量的输入并多次进行next()方法的调用。

import java.util.Scanner;
public class HowScanner {
 	public static void main(String[] args) {
 		Scanner scanner = new 		
 		Scanner(System.in);
 		String word = scanner.next();
 		System.out.println("|" + word + "|");
 	}
}

2. 判断是否还要继续输入：hasNext()
此方法的主要作用是判断是否还有数据输入，此时 变量.hasNext() 的值类型是 boolean，当为true时，进行next()方法的调用进行数据输入；当为false时，键盘输入 Ctrl+D，终止程序运行
当输入回车时，没有输出值

import java.util.Scanner;
public class HowScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = 0;
        // scanner.hasNext() 《=》 方法调用(函数调用)
        // 返回值类型：boolean
        // true 代表用户输入了下一个单词
        // false 代表用户输入了 Ctrl+D
        // hasNext() 不返回，代表用户没有输入
        while (scanner.hasNext()) {
            // scanner.next() 《=》 方法调用
            // 返回值类型：String
            // 含义：读取用户输入的下一个单词（以空格、\t、回车）
            // 如果不输入，scanner.hasNext()不返回
            String word = scanner.next();
            String line = count + ": |" + word + "|";
            System.out.println(line);
            count++;
        }
        // 要循环结束，从键盘输入 Ctrl+D
        System.out.println("循环已经结束");
    }
}

3.读取一行：nextLine()
此方法与next()方法用法相同，区别在于next()方法一次只能读入一个数据，但nextLine()方法一次读入一行数据

import java.util.Scanner;
public class HowScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        System.out.println("|" + s + "|");
    }
}

4.判断是否需要继续：hasNextLine()
此方法的主要作用是判断是否还有数据输入，此时 变量.hasNextLine() 的值类型是 boolean，当为true时，进行nextLine()方法的调用进行数据输入；当为false时，键盘输入 Ctrl+D，终止程序运行
当输入回车时即输入了空行，会输出空并打印

import java.util.Scanner;
public class HowScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = 0;
        while (scanner.hasNextLine()) {
            String word = scanner.nextLine();
            String line = count + "：|" + word + "|";
            System.out.println(line);
            count++;
        }
        System.out.println("循环已经结束");
    }
}

5.输入字符如何输出数字：nextInt()
在前面的学习中，当输入的是字符，则需要进行数值类型的转换，以 int 类型为例

String w = "1";
int s = Integer.parseInt(w);

但是 Scanner 类中有提供转换的方法工具：变量.nextInt()

Scanner sca = new Scanner(System.in);
// 此方法直接将输入的数据转换成 int 类型
int i = sca.nextInt();
System.out.println(i + 100);

6.判断是否继续有数据输入：hasNextInt()
此方法的主要作用是判断是否还有数据输入，此时 变量.hasNextInt() 的值类型是 boolean，当为true时，进行nextInt()方法的调用进行数据输入；当为false时，或键盘输入 Ctrl+D，终止程序运行
当输入回车时即输入了空行，不返回；输入非字符，程序终止

Scanner sca = new Scanner(System.in);
 // 此方法直接将输入的数据转换成 int 类型
 /*int i = sca.nextInt();
 System.out.println(i + 100);*/
 while (sca.hasNextInt()) {
 	int s = sca.nextInt();
 	System.out.println(s + 100);
 }

Scanner sca = new Scanner(System.in);
 // 此方法直接将输入的数据转换成 int 类型
 while (sca.hasNextInt(16)) {
 	// 括号中的数字代表了该处数字按16进制读入
 	int s = sca.nextInt(16);
 	// 但打印输入是按10进制输出
 	System.out.println(s + 100);
 }

7.Scanner s1; // 定义s1变量，类型是Scanner
所使用的包：import java.util.Scanner;