Java语言基础（二）：运算符

最新推荐文章于 2024-08-19 23:32:37 发布

钱春华

最新推荐文章于 2024-08-19 23:32:37 发布

阅读量1.4k

点赞数 1

分类专栏： java 文章标签： java 语言运算符 scanner

本文链接：https://blog.csdn.net/qian_ch/article/details/53725601

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

在Java中，使用算术运算符 + 、- 、* 、/ 表示加、减、乘、除运算。当参与 / 运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法，整数的求余操作（有时称为取模）用 % 表示。比如说：15/2等于7,15%2等于1,15.0/2等于7.5.
我们需要注意的是，整数被0除将会产生一个异常，而浮点数被0除将会得到无穷大或者NaN结果。
在实际的开发过程中，我们在赋值语句中采用一种简化的格式书写二元算数运算符。
例如：

x += 5;
就等价于：
x = x+5;
（在通常我们写代码的时候，将运算符放在复制号的左侧，如 *= 或 %=）

一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。我们需要注意的是：boolean类型不能转换为其他的数据类型。
默认的转换：(从小到大的转换)
A:byte,short,char—int—long—float—double
B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
下面我们来看一段我写的代码：

public class TypeDemo01 {
	public static void main(String[] args) {
		//直接输出的方式做加法
		//System.out.println(3 + 4);
	
		//两个int类型做加法
		int x = 3;
		int y = 4;
		int z = x + y;
		System.out.println(z);
		
		//定义一个byte类型，一个int类型，做加法
		byte a = 3;
		int b = 4;
		System.out.println(a + b);
		
		//可能损失精度
		//byte c =  a + b;
		int c = a + b;
		System.out.println(c);
	}
}

从控制台读取数据（键盘录入）

前面的一些案例呢我们都是在程序中写死的，我们用户可以不可以自己在程序应用中输入呢？当然可以，下面我们来介绍一下从控制台读取数据：为了让程序的数据更符合开发的数据，我们就加入了键盘录入。让程序更灵活一下。
那么，我们如何实现键盘数据的录入呢?

（1）导入Java的 API Scanner 类
	·import java.util.Scanner;
	·在 package 之后，class 之前
	·可以写多个，表示导入多个类
	·可以用 * 导入一个包(少见) （import java.util.*;）
（2）使用Scanner
	·创建对象console:控制台（Scanner console=new Scanner(System.in);）
	·调用 Scanner 类型提供的API方法从控制台获取数据。（double d=console.nextDouble();）

如何从控制台读取一个字符？
Scanner没有提供读取一个字符的方法变通的解决办法:
（1）利用Scanner从控制台读取一串字符：
String str = console.nextLine();
（2）取字符串中的第一个字符：
char ch = str.charAt(0);
下面我们来演示一个从控制台输入一个数，然后读取，如下代码：

import java.util.Scanner;

public class ScannerDemo {
	public static void main(String[] args) {
		//创建键盘录入数据对象
		Scanner sc = new Scanner(System.in);		
		System.out.println("请你输入一个数据：");
		int x = sc.nextInt();		
		System.out.println("你输入的数据是："+x);
	}
}

在Java语言中，运算符可分为关系运算、逻辑运算、赋值运算、赋值复合运算、字符串连接运算和3元运算。下面我们来逐一介绍：

1、关系运算与boolean运算符

（1）运输符号 > < >= <= == !=
（2）比较两个数值的关系
（3）比较结果是boolean类型，成立true，不成立false
下面看一段我写的案例代码：

public class OperatorDemo {
	public static void main(String[] args) {
		int x = 3;
		int y = 4;
		int z = 3;
	
		System.out.println(x == y);
		System.out.println(x == z);
		System.out.println((x+y) == (x+z));
		System.out.println("------------");
		
		System.out.println(x != y);
		System.out.println(x > y);
		System.out.println(x >= y);
		System.out.println(x < y);
		System.out.println(x <= y);
		System.out.println("------------");
		
		int a = 10;
		int b = 20;
		
		//boolean flag = (a == b);
		//boolean flag = (a = b); //这个是有问题的，不兼容的类型
		//System.out.println(flag);
		
		int c = (a = b); //把b赋值给a，然后把a留下来
		System.out.println(c);
	}
}

2、自增运算符和自减运算符

当然，程序员都知道加1、减1是数值变量最常见的操作。在Java中，借鉴了C和C++的实现方式，也使用了自增、自减运算符：n++将变量n的当前值加1；n–将n的值减1，例如：

int n = 12;
n++;//n++=12   n=n+1——>13

n的值为13.因为这些运算符改变了运算的值，所以它的操作不能是数值。比如说 5++就是一条非法的语句。
实际上呢，这两个运算符有两种形式。上面介绍的是运算符放在操作数后面的“后缀”的形式，还有一种“前缀”形式，++n。这两种方式都是对变量增加1。但是在表达式中，这两种形式就有区别了。前缀方式先进行加1运算；后缀方式则使用变量原来的值。举个例子吧：

int m = 8;
int n = 9;
int a = m++;
System.out.println(a);//m++=8 其实 m=m+1 所以 a=9
int c = ++m;
System.out.println(c);//++m 先加1再赋值，因此，m=m+1=10 所以c=10
int b = n--;
System.out.println(b);//与上面同理：n--  n=n-1 值为8
int d = --n;
System.out.println(d);//先减1再赋值 因此是 n=n-1=7

3、逻辑运算

（1）运算符   &&(与，并且)  ||(或，或者)   !（非，否则）
（2）对boolean 类型数据进行计算，得到boolean类型结果
（3）运输规则：
	·&& 并且：两个boolean参与运算，都是true，则返回true
		<1>false && false -> false
		<2>false && true -> false
		<3>true && false -> false
		<4>true && true -> true
		<5>&& 运算的逻辑意义：两个都成立才成立
	·|| 或运算：两个boolean参与运算，只有一个是true，返回结果就是true 
		<1>false || false -> false
		<2>false || true -> true
		<3>true || false -> true
		<4>true || true -> true
		<5>逻辑意义：只有一个成立即可
	·! 非运算：单个boolean类型参与运算 
		<1>!true -> false
		<2>!false -> true

下面通过一段代码来说明：
案例1：判断某字符是否为大写英文字符

char c = 'G';
boolean l = 'A'<=c && c<='Z';
System.out.println(l); 
//判断一个字符c，是否为英文字符
//  一个字符c是大写或者是小写
//(c是大写) || (c是小写)
//('A'<=c&&c<='Z')||('a'<=c&&c<='z')
c = 't';
boolean pass=('A'<=c&&c<='Z')||('a'<=c&&c<='z');
System.out.println(pass);

案例2：判断一个人的年龄是否介于18到50之间

Scanner console = new Scanner(System.in); 
System.out.print("输入年龄:");
int age = console.nextInt();
//判断这个age代表年龄，介于18到50之间
boolean b = 18<=age && age<=50;
System.out.println(b);

4、短路逻辑判断现象

Java 中&& 和 || 运算是短路的运行，在第一个表达式能够确定整体结果情况下，不在计算第二个表达式。
案例代码1：

/*
 * 短路逻辑判断测试
 */
int age = 30;
char sex = '男';
boolean pass = sex=='女' && age++>60;
System.out.println(pass);
System.out.println(age);
//输出结果 age 是30说明发生短路判断

案例代码2：

/*
 * 短路的或运算
 */
int age = 30;
char sex='女';
boolean b = sex=='女' || age++ > 60;
System.out.println(b);//true
System.out.println(age);//30
//age的值30，说明发生了短路

5、赋值运算

（1）运算符号 =
（2）将数据从右侧存储到左侧（int i = 5;）
（3）赋值运算的优先级非常低，在最后执行
（4）赋值运算表达有值：是赋值的值
（5）= 的结合性：先执行右侧的等号，再执行左侧等号
下面是我写的一段案例代码：

int a=5, b=6, c=7, d;
d = a+b%c;
d = d+2;
Systen.out.println(d);//13
System.out.println(a=8);
System.out.println(a)
System.out.println(a=8%3);
System.out.println(a)
a = (b = (c = 5));
a = (b=5)+c%3;
System.out.println(a);

6、扩展赋值运算（复合赋值运算）

下面我们来看一段代码：

//得到偶数序列
int i = 0;//0
i = i+2; //2  替换为 i += 2; i增加2
i = i+2; //4
i = i+2; //6
//使用复合赋值运算的偶数序列
i =0;
i+=2;
i+=2;
i+=2;

（1）一个2元运算符 ? 与 = 复合
	·X = X ? n 复合为 X ?= n
（2）使用方式：先正常思考，如果能够简化为复合赋值运算，在进行替换。
（3）复合赋值运算包含强制类型转换计算 
	·int a = 5;
	·a *= 4 完全等价于 a = (int)(a * 4);
	·a *= 1.4; // a=(int)(a * 1.4);
	·byte b = 6;
	·b += 6;// b = (byte)(b + 6);

下面演示复合运算的案例：
案例1：折上折，5折再打5折

double total=100;
//total = total * 0.5;
total *= 0.5;
total *= 0.5;
System.out.println(total);

案例2：内嵌强制类型转换

/*
 * 复合赋值运算，内嵌强制类型转换！！
 */
char c = 'A';
System.out.println(c);//A
c += 2;// c = (char)(c+2)
System.out.println(c);//C
c += 2.2;// c = (char)(c+2.2)
System.out.println(c);//E
c += 12281722781L;
//  c = (char)(c+12281722781L)
System.out.println(c) ;

7、字符串连接运算

一个符号 “+” 两种功能，称为运算符重载。

（1）运算符 + 
（2）运算规则区别：
	·当 + 的两端都是数值，执行数值加法计算
	·当 + 的一端出现字符串时候，执行字符串连接
（3）连接时候数据转换规则： 
	·数值转换为10进制连接
	·char类型按照字符进行连接
	·boolean 按照 true 、false连接
（4）数值加法和连接运算优先级一样，按照从左到右顺序结合计算。 
	·1 + 5 + 4 + "A" + 4 + 5 + 1 // 10A541
	·1 + 5 + 4 + "A" + (4 + 5 + 1) //10A10
	·'A'+1+"A" 比较 "A"+1+'A'
	·66A A1A

案例代码：

int a = 5, b = 6;
char c = 'A';
String str = "ABC";
int n = a+b;//11
int num = a+c;// 70
String s1 = str + a;//字符串连接 ABC5
String s2 = a + str;//字符串连接 5ABC
String s3 = str+str;// "ABCABC"
String s4 = str+c;//ABCA
String s5 = str+'c';//ABCc

8、3元运算（条件运算）

三目运算符格式：比较表达式?表达式1:表达式2;
执行流程：
根据比较表达式的计算返回一个true或者false。
如果是true，就把表达式1作为结果。
下面是我写的案例代码：

public class OperatorDemo {
	public static void main(String[] args) {
		int x = 100;
		int y = 200;
		
		int z = ((x > y)? x: y);
		
		//int z = ((x < y)? x: y);
		
		//int z = ((x == y)? x: y);
		
		//报错
		//int z = ((x = y)? x : y);
		
		System.out.println("z:"+z);
	}
}

案例：
获取两个整数中的最大值
获取三个整数中的最大值
比较两个整数是否相同

public class Test {
	public static void main(String[] args) {
		//获取两个整数中的最大值
		int x = 100;
		int y = 200;
		
		int max = (x > y? x: y);
		System.out.println("max:"+max);
		System.out.println("--------");
		
		//获取三个整数中的最大值
		int a = 10;
		int b = 30;
		int c = 20;
		
		//分两步：
		//A:先比较a,b的最大值
		//B:拿a,b的最大值在和c进行比较
		int temp = ((a > b)? a: b);
		//System.out.println(temp);
		int max1 = (temp > c? temp: c);
		System.out.println("max1:"+max1);
		
		//一步搞定
		//int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
		//这种做法不推荐。
		//int max2 = a > b?a > c? a: c:b > c? b: c;
		//System.out.println("max2:"+max2);
		System.out.println("--------");
		
		//比较两个整数是否相同
		int m = 100;
		int n = 200;
		
		//boolean flag = (m == n)? true: false;
		boolean flag = (m == n);
		System.out.println(flag);
	}
}

9、位运算符

位运算符有哪些呢？其中有：
&,|,^,~,<<,>>,>>>
我们需要注意的是：要做位运算，首先要把数据转换为二进制。
下面我们通过一段代码来介绍一下位运算符：

public class OperatorDemo01 {
	public static void main(String[] args) {
		//&,|,^,~		
		int a = 3;
		int b = 4;		
		System.out.println(3 & 4);
		System.out.println(3 | 4);
		System.out.println(3 ^ 4);
		System.out.println(~3);
	}
}
/*
	分析：因为是位运算，所以我们必须先把数据换算成二进制。
	
	3的二进制：11
		00000000 00000000 00000000 00000011
	4的二进制：100
		00000000 00000000 00000000 00000100
	
	&位与运算：有0则0。
		00000000 00000000 00000000 00000011
	   &00000000 00000000 00000000 00000100
		-----------------------------------
		00000000 00000000 00000000 00000000
		结果是：0
		
	|位或运算：有1则1。
		00000000 00000000 00000000 00000011
	   |00000000 00000000 00000000 00000100
		-----------------------------------
		00000000 00000000 00000000 00000111
		结果是：7
		
	^位异或运算：相同则0，不同则1。
		00000000 00000000 00000000 00000011
	   &00000000 00000000 00000000 00000100
		-----------------------------------
		00000000 00000000 00000000 00000111
		结果是：7
		
	~按位取反运算符：0变1，1变0
		00000000 00000000 00000000 00000011
	   ~11111111 11111111 11111111 11111100 (补码)
	   
	   补码：11111111 11111111 11111111 11111100
	   反码：11111111 11111111 11111111 11111011
	   原码：10000000 00000000 00000000 00000100
		结果是：-4
*/

（1）如下代码：

/*
	^的特点：一个数据对另一个数据位异或两次，该数本身不变。
*/
public class OperatorDemo02 {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		System.out.println(a ^ b ^ b); //10
		System.out.println(a ^ b ^ a); //20
	}
}

（2）如下代码：

/*
	<<:左移	左边最高位丢弃，右边补齐0
	>>:右移	最高位是0，左边补齐0；最高为是1，左边补齐1
	>>>:无符号右移 无论最高位是0还是1，左边补齐0	
	面试题：
		请用最有效率的方式写出计算2乘以8的结果?
			2 * 8			
			2 << 3
*/
public class OperatorDemo03 {
	public static void main(String[] args) {
		//<< 把<<左边的数据乘以2的移动次幂
		System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
	
		//>> 把>>左边的数据除以2的移动次幂
		System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
		System.out.println(24 >>> 2);
		
		System.out.println(-24 >> 2); 
		System.out.println(-24 >>> 2);
	}
}