JAVA中如何提取算式中的运算符,Java 基础（7）——运算符

学完基础的变量常量等知识。再往后和变量常量紧密相关的当然是加减乘除等等运算方法了~(当然加减乘除也只是一部分)

首先按照运算过程参与的元素，把运算符号简单粗暴的分为一元运算符、二元运算符、三元运算符等等。

一元运算符就是只有一个元素参加的运算，如【 !a 】；

二元运算符就是只有二个元素参加的运算，如【 a + b 】；

三元运算符就是只有三个元素参加的运算，如【 a ? b : c 】；

……(*^▽^*)后面还有没有我没有去仔细了解，为了严谨，还是加上省略号哈哈。

算术运算符

咱们先学学小学三年级及之前的运算符‘+’、‘-’、‘*’、‘/’。

1+1=2，1-1=0等等算式放到Java中呢，我们也是一样的这么写~

来，我们先搞两个变量在这里：

double a = 1998.1109;

double b = 2019.0413;

然后后面就用这两个变量来算了~

加 +

double c = a + b; //这里也是用加法让c等于a+bSystem.out.println("a+b="+c);

输出结果：

减 -

double c = a - b; //这里也是同样的减法

System.out.println("a-b="+c);

输出结果：

乘 *

double c = a * b; //与手写不一样的是，计算机中乘法用*

System.out.println("a*b="+c);

输出结果：

除 /

double c = a / b; //除法也与手写不一样，计算机中除法用/

System.out.println("a/b="+c);

输出结果：

说完上面的加减乘除法，我们还有几个相对比价“高级”的计算符号需要去study：

取余 %

取余：应该就是 取得余数 的意思了吧~

余数呢，就是在整数的除法中，当不能整除时，就产生了余数。比如3除2，商是1，余数是1.

……额，我怎么开始解释小学数学了 -_-|| 上代码吧…

double c = b % a; //整除

System.out.println("a%b="+c);

输出结果：

额，这我就不验证了…应该是对的了。

自增 ++ (自减 --)

自增：就是程序运行到某一行，变量自己就想通了，给自己加了个1……这就是自增(在原有的变量中加1)

比如：

a = a + 1;

System.out.println("a="+a);

输出结果：

上面是没有用到自增的运算符的计算，就是一个简单的加法计算。那么用自增呢，就更简单了：

a ++; //自增运算符

System.out.println("自增：a="+a);

输出结果：

此外，关于自增自减，必须要讲到的是自增自减符的位置问题！

先来一段代码：

a = 1998.1109;//重置a的值为1998.1109

System.out.println("先++：" + ++a);

a= 1998.1109;//重置a的值为1998.1109

System.out.println("后++：" + a++);//不重置a的值了

System.out.println("最后a变成了：" + a);

然后看一下结果：

发现了什么呢？

先进行自增运算的输出的值为 a = 1999.1109，完成了自增运算

后进行自增运算的输出的值仍然为 a 原来的值(1998.1109)。

最后进行a值的检查的时候，a却还是变成了1999.1109.

So，真相大白了吧：

++a,会先把a做加1操作后，把a输出，就是算好了的结果。

a++会先输出a，然后再算++。

就是这么回事儿，其实按照从左到右的顺序执行代码了(*^▽^*)

自减(每次减一)同理，就不过多论述了~

赋值运算符

赋值运算符，一般来说就是数学中的“=”，但是我们不能把它叫做等于哦~

之前的代码大家也都看到了。

double a = 1998.1109;

这样的代码，读作：a等于1998.1109是错的哦，应该是将1998.1109赋值给a。

这个逻辑是什么样的呢？

我的理解：等号左边的a是不确定的，右边的1998.1109是确定的，将确定的值赋给不确定的变量，使变量的确定就叫赋值。【等于的两边是等价的，而赋值确实右边的值成立后，左边的变量才成立。】

除了上面的“=”之外，还有许多其他的赋值运算符，他们由“=”前面加上其他的运算符组成，比如：

表 7 - 1 赋值运算符

运算符

用法

等效表达式

+=

a += b

a = a +b

-=

a -= b

a = a - b

*=

a *= b

a = a * b

/=

a /= b

a = a /b

%=

a %= b

a = a % b

&=

a &= b

a = a & b

|=

a |= b

a = a | b

^=

a ^= b

a = a ^ b

>>=

a >>= b

a = a >> b

<<=

a <<= b

a = a << b

>>>=

a >>>= b

a = a >>> b

For example:(以+=为例)

int a = 0;

a+=2; System.out.println("a="+a);

输出结果：

关系运算符

专业一点的话：关系运算符用来比较两个值，返回布尔类型的值：true 或 false 。关系运算符都是二元运算符。

两个变量之间的关系，我们可以用仍然用ab来作为例子进行比较。

a与b之间，硬要搞点什么关系的话，无非就是谁大谁小或者相等不相等的关系了。类似于>、

然后常用的关系运算符还是列出来一下：

表 7 - 2 关系运算符

运算符

用法

返回true需要满足的条件

>

a > b

a 大于 b

<

a < b

a 小于 b

>=

a >= b

a 大于等于 b

<=

a <= b

a 小于等于 b

==

a == b

a 和 b 相等

!=

a != b

a 和 b 不相等

好，这里列出一段代码来帮助理解：

boolean a = 1>0; //真的，1确实大于0

boolean b = 1<0; //假的

boolean c = 1>=0; //真的

boolean d = 1<=0; //假的

boolean e = 1!=0; //真的

boolean f = 1==0; //假的

System.out.println("a="+a);

System.out.println("b="+b);

System.out.println("c="+c);

System.out.println("d="+d);

System.out.println("e="+e);

System.out.println("f="+f);

那么输出结果是不是注释所预料到的呢？来看一下

bingo~~

逻辑运算符

1. 如果今天出太阳并且篮球场还有位置，我就去打篮球。

【出太阳】和【篮球场有位置】都得成立，都得是真的，我才出去【打篮球】。有一个前提条件不满足，我就懒得去了。用逻辑运算符表达就是

【出太阳】&&【篮球场有位置】

“&&” 符号就是 与 逻辑符了。符号两边都成立，都为真才会返回一个 true 值，否则都是 false 。

用代码体验一下：

boolean a = (1 > 0) && (2 > 0);//(1 > 0)为真， (2 > 0)为真，两个都成立，&&运算返回true

System.out.println("a = "+a);boolean b = (1 < 0) && (2 > 0);//(1 < 0)为假， (2 > 0)为真，两个有一个成立，&&运算返回false

System.out.println("b = "+b);boolean c = (1 < 0) && (2 < 0);//(1 < 0)为假， (2 < 0)为假，两个都不成立，&&运算返回false

System.out.println("c = "+c);

输出结果：

2. 如果今天出太阳或者下雨了，我就得带把伞出门。

【出太阳】和【下雨】只要有一个成立了，不管是【出太阳】还是【下雨】，我都得【带伞出门】。用逻辑运算符表达就是

【出太阳】||【下雨】

“||” 符号就是 或 逻辑符了。符号两边只有有一个成立，只要有一个为真就会返回一个 true 值，两个条件都是假的话，才会返回 false值。

用代码体验一下：

boolean a = (1 > 0) || (2 > 0);//(1 > 0)为真， (2 > 0)为真，两个都成立，||运算返回true

System.out.println("a = "+a);boolean b = (1 < 0) || (2 > 0);//(1 < 0)为假， (2 > 0)为真，两个有一个成立，||运算返回true

System.out.println("b = "+b);boolean c = (1 < 0) || (2 < 0);//(1 < 0)为假， (2 < 0)为假，两个都不成立，||运算返回false

System.out.println("c = "+c);

输出结果：

3. 如果今天不上班，我就呆在家里。

不是【上班】的日子，我才呆在家里。不是 { 不【上班】} 的时候，我当然得去上班了……用逻辑运算符表达就是

!【上班】

“!” 符号就是 取反 逻辑符了。表示否则的意思。

用代码体验一下：

boolean a = !(1 > 0);//(1 > 0) 为真，经过取反运算之后为假

System.out.println("a = "+a);boolean b = !(1 < 0);//(1 < 0) 为假，经过取反运算之后为真

System.out.println("a = "+b);

输出结果：

位运算符

位运算符是用来对二进制位进行操作的运算符。(不常用的话可以只了解一下就行了哦~)

表 7 - 3 位运算符

运算符

用法

描述

~

~ a

按位取反

&

a & b

按位与

|

a | b

按位或

^

a ^ b

按位异或

>>

a >> b

a 右移 b 位

<<

a << b

a 左移 b 位

>>>

a >>> b

a 无符号右移 b 位

什么意思呢？一个个来聊。

按位取反  ~  ，对数据的每个二进制位都取反(0变1,1变0)ep: ~111000 = 000111

按位与  &  ，对两个数据进行按位与运算(同一个位置有一个为0，则结果为0，其他情况为1)ep:

这个可以用来对二进制某些位进行清零操作，比如11111，我想让他第四个变成0，只需与11101进行按位与运算即可。

按位或  |  ，对两个数据进行按位或运算(同一个位置有一个为1，则结果为1，其他情况为0)ep:

同理，这个可以用来将二进制某些位变成1，比如11101，我想让他第四个变成0，只需与11111进行按位或运算即可。

按位异或  ^  ，对两个数据进行按位异或运算(同一个位置两个相同，则结果为0，不同则为1)ep:

这个可以用来将二进制某些位进行翻转操作，比如10101，我想让他前三位翻转，只需与11100进行按位或运算即可。还可以用于进行两个值的交换：

左移  <

在不溢出的情况下可以用来实现 *2 操作。

右移  >>  ，将一个数的各二进位全部右移，第一位是多少就补多少。ep:

在不溢出的情况下可以用来实现 /2 操作。

无符号右移  >>>  ，将一个数的各二进位无符号全部右移，高位补0，ep:

如果两个数据长度不同，那么在位运算时会先将短型前补满，如果为正，则全补0，如果为负，则全补1。

其他运算符

除了以上几种运算符以外，Java中还有一些特殊的运算符~

1. Java实例运算符   instanceof

这个用来测试一个对象是否是一个指定的类的实例。

2. Java内存分配运算符   new

很多时候我们说new一个对象，其实是为这个对象分配一个内存存储它。

3. 三目运算符  a ? b : c

这个的意思就是： a 是真的就输出冒号 : 前面的 b ，a 是假的，就执行冒输出: 后面的 c 。

int a = 1 >2 ? 3 : 6;

System.out.println("a = "+a);

输出结果：

#运算符的优先级

当然，当从小学一年级开始慢慢深入学习，我们肯定不会是一直就是要么加要么减的运算了。多个运算符写在一起的时候，肯定会有优先计算的符号，比如加减乘除中，“先乘除后加减，有括号的先算括号里面的。”

Java中也一样~这里再次贴上一个表：

表 7 - 4 运算符的优先级

优先级

运算符

综合性

1

()   []   .

从左到右

2

!   +(正)   -(负)   ~   ++   --

从右到左

3

*   /   %

从左到右

4

+(加)   -(减)

从左到右

5

<>   >>>

从左到右

6

=  >>  instanceof

从左到右

7

==   !=

从左到右

8

&(按位与)

从左到右

9

^

从左到右

10

|

从左到右

11

&&

从左到右

12

||

从左到右

13

? :(三目运算符)

从右到左

14

=   +=   -=   *=   /=   %=   &=   |=   ^=   ~=   <<=   >>=   >>>=

从右到左

注：　　优先级为1的优先级最高，14为优先级最低。

综合性是指运算符结合的顺序，一般从左到右。

注意区分正负号与加减号的区别。

注2：emm哈哈哈，其实不用刻意记这个表，在该打括号的地方打上括号就什么都不怕了！！！

int a = 1 >2 ? (12 - 8) : (67-3);

像这样的，也会方便代码的阅读性。

--------------------------------------------------

以上，阿里嘎多，20190413 from ahanwhite。