Java——运算符

一、算数运算符

1、+（正号）

表示一个数字为正值，例如 +1 就是正一，一般可以省略，例如 1 也代表正一。

2、-（负号）

表示一个数字为负值，例如 -1 就是负一。

3、+（加号）

进行算数加运算，例如 1 + 1 = 2 。或者是变量相加。

int a = 10;
int b = 20;
int res = a + b;// res 为30

4、-（减号）

进行算数减运算，例如 1 - 1 = 0 。或者是变量相减。

int a = 10;
int b = 5;
int res = a - b;// res 为5

5、*（乘号）

进行算数乘运算，例如 2 * 2 = 4。或者是变量相乘。

int a = 2;
int b = 3;
int res = a * b;// res 为6

6、/（除号）

进行算数除运算，例如 6 / 3 = 2 。或者是变量相除。这里有一个特殊，这里的除法运算是有两种的，一种是整数除法，一种是浮点数除法。

当两个操作数都是整数类型（如 int 或 long）时，/ 运算符执行整数除法，结果也是一个整数，任何小数部分都会被截断（即结果向零取整）。

        int a = 5;
		int b = 2;
		int res = a / b;//这里使用int变量来存储，如果不报错的话，则说明这里的a / b的结果是整型
		System.out.println(res);

这里没有报错，说明这里的 a / b 得到的就是整型数据，最终运行结果为：

这说明这里进行的是整型除法。我们都知道 5 / 2 的结果应该为 2.5 ，但这里是 2 ，就是因为这里的小数部分被截去了。

当至少有一个操作数是浮点数类型（如 float 或 double）时，/ 运算符执行浮点数除法，结果也是一个浮点数。

        double num1 = 5.0;
		int num2 = 2;
		double res = num1 / num2;
		System.out.println(res);

这里的运行结果是：

说明这里进行的是浮点数除法。

7、%（取模）

取模就是取余，也就是计算一个数除以另一个数的余数。例如 3 % 2 = 1，也就是 3 除以 2 的余数是 1 。

int a = 10;
int b = 3;
int res = a % b;// res 为1

对于取模的算法是以下的公式：

a % b = a - (int)a / b * b

也就是通过这个 a / b 是整数除法，可以得到商，然后通过使用被除数减去商与除数乘积得到余数。前面的一个 (int) 强制转换是当 a 为小数时使用的。例如：

10 % 3 = 10 - 10 / 3 * 3 = 1。

8、++（自增运算符）

使用于变量自身加一，例如 a++ 就相当于 a = a + 1 ，这会导致变量的值发生改变，正因如此，这个运算符不能对常量使用。

自增运算符以及下面的自减运算符都有一个特点，就是可以前置也可以后置，但这两种方式实现的效果不同。

1）前置++

前置++，就如 ++a ，是先将变量的值自增一，然后再使用变量。也就是先自增，再使用。例如：

    int a = 1;
	int b = ++a;//这里是先自增，后使用，所以是先 a = a + 1，然后 b = a，所以这里 b 为 2
	System.out.println("b = " + b);
	System.out.println("a = " + a);

这里是先自增，后使用，所以是先 a = a + 1，然后 b = a，这样b的值就是 2 ，a 也是自增过的，所以 a 也是2，运行结果：

2）后置++

后置++，就如 a++，是先使用变量，然后变量的值再自增一。也就是先使用，再自增。例如：

	int a = 1;
	int b = a++;//这里是先使用，再自增，所以是 b = a，然后 a = a + 1，这样b的值就是1
	System.out.println("b = " + b);
	System.out.println("a = " + a);

这里是先使用，再自增，所以是 b = a，然后 a = a + 1，这样b的值就是 1 ，然后 a 是自增一后的，所以 a 的值是2。运行结果：

9、--（自减运算符）

使用于变量自身减一，例如 a-- 就相当于 a = a - 1 ，这会导致变量的值发生改变，正因如此，这个运算符不能对常量使用。

前置 -- 和后置 -- 与前置 ++ 和后置 ++ 的情况类似。

1）前置--

前置--，就如 --a ，是先将变量的值自减一，然后再使用变量。也就是先自减，再使用。例如：

    int a = 2;
	int b = --a;//这里是先自减，后使用，所以是先 a = a - 1，然后 b = a，所以这里 b 为 1
	System.out.println("b = " + b);
	System.out.println("a = " + a);

这里是先自减，后使用，所以是先 a = a - 1，然后 b = a，所以这里 b 为 1，a 也是自减后的，所以 a 为1。运行结果：

2）后置--

后置--，就如 a--，是先使用变量，然后变量的值再自减一。也就是先使用，再自减。例如：

    int a = 2;
	int b = a--;//这里是先使用，后自减，所以是先 b = a，然后 a = a - 1，所以这里 b 为 2
	System.out.println("b = " + b);
	System.out.println("a = " + a);

这里是先使用，后自减，所以是先 b = a，然后 a = a - 1，所以这里 b 为 2，a 是自减后的，所以 a 是 1 。运行结果：

10、+（字符串连接）

小细节

后置++补充

int i = 1;
i = i++;
System.out.println(i);

运行结果：

这里是因为，对于这里的的内部实现实际上可以具象化成这样：

所以 i 是先变成了 2 ，然后又变成了 1 。

实际上对于一般的后置加加也是这样的原理，也就是会创建一个临时变量来存储原本的值，然后再自增，最后再使用临时变量中原来的值。

对于上面我们描述的先使用后递增，实际上是对于一般情况下的简化，对于上面这个特殊案例，先使用，后递增这个描述就有些错误了。

对于下面这种一般情况：

int i = 1;
a = i++;

我们就可以分析它的底层实现：

这时简化成先使用，后递增，就没有什么错误，但实际上的顺序是不对的。实际上是先递增，然后使用，只不过使用的是临时变量存储的递增之前的值。

前置++补充

对于前置++则没有上面的问题：

int i = 1;
i = ++i;

这里的步骤就像是：

所以这里与我们简化的分析是一致的，先自增，后使用。

二、关系运算符

关系运算符用于比较两个值或表达式，关系运算符的结果都是 boolean 类型的，也就是说关系运算符会返回一个布尔值（true或false）。

关系运算符组成的表达式，我们称为关系表达式，例如 a > b 就是一个关系表达式。

关系运算符主要有以下几种：

1、==（等于）

用于比较两个操作数是否相等。如果相等，则返回true，否则返回false。

public class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 30;
		System.out.println(a + " == " + b + " is " + (a == b));
	}
}

运行结果：

2、!=（不等于）

用于比较两个操作数是否不相等。如果不相等，则返回true，否则返回false。

    int a = 10;
	int b = 30;
	System.out.println(a + " != " + b + " is " + (a != b));

运行结果

3、>（大于）

用于判断左操作数是否大于右操作数。如果是，则返回true，否则返回false。

    int a = 10;
	int b = 30;
	System.out.println(a + " > " + b + " is " + (a > b));

运行结果：

4、<（小于）

用于判断