Java运算符总结

1、运算符概述

运算符是一种特殊的符号，用以表示算数的运算、赋值和比较等。

算数运算符	赋值运算符	
逻辑运算符	比较运算符(关系运算符)	
位运算符		三元运算符

2、算数运算符

2.1 ++和–的用法

1、当++(–)单独使用时放在前面或者后面的操作都一样(常见用法):
2、当++(–)参与运算的时候: a++(–)先赋值，后自增，(–)++a先自增，后赋值
自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量！例如 5++ 、 8-- 等写法都是错误的。

        //前++ 后++ --用法相同
        int NUM1 = 10;
        int NUM2 = ++NUM1;
        System.out.println("N1="+NUM1+"\nN2="+NUM2);

        int NUM3 = 10;
        int NUM4 = NUM3++;
        System.out.println("N3="+NUM3+"\nN4="+NUM4);
        print result:
        N1=11
		N2=11
		N3=11
		N4=10

2.1.1 ++和–的练习

问：此程序会不会报错为什么?
答：此处会报错，因为b和1都是整数类型,需要进行强制转换否则会损失精度

byte b=10;
b++;
b=b+1; 
//解：强制类型转换b = (byte)(b+1);

2.2 %的用法

%取余运算符
结果的符号与被模数的符号相同
开发中常用%来判断是否能被除尽的情况
当左边的绝对值小于右边时,结果是左边
当左边的绝对值等于右边时,或者是右边的倍数时,结果为0
当左边的绝对值大于右边时,结果是余数
%运算符结果的符号之和左边有关系,与右边无关系
任何一个整数%2的结果不是0就是1可以用来当做切换条件

        int m1 =12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);
        int m2 = -12;
        int n2 = 5;
        System.out.println("m1 % n1 = " + m2 % n2);
        int m3 =12;
        int n3 = -5;
        System.out.println("m1 % n1 = " + m3 % n3);
        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);
        print result:
        m1 % n1 = 2
		m1 % n1 = -2
		m1 % n1 = 2
		m4 % n4 = -2

3、赋值运算符

当符号"="两边的数值不一致的时候，可以使用自动类型转换或者强制类型转换，支持连续赋值。
其运算结果不会改变该变量的数据类型。

3.1 面试题

问：此程序会不会报错?为什么？
答：会报错，因为short类型和int类型相加时,自动转换为int类型,需要进行强制转换。

short s=1; 
s=s+1; 
两种解决方案
1、强转:
short s=1; 
s=(short)(s+1);
2、赋值运算符:
short s=1; 
s +=1; 
+=把左右两边的变量相加赋予给左边的常量所以说得出结果为2

3.2 练习题

题目要求：实现+2的操作和+1的操作。

源码：int num =10;
//+2的实现
num +=2;	//优先使用
num = num+2;
----------------------------------------
//+1的实现
num++;	//优先使用
num +=1;
num = num+1;

4、比较运算符

比较运算符的结果都是boolean类型的，true or false
比较运算不要把"==“当作”="

5、逻辑运算符

单符号读逻辑、双符号读短路

5.1 |与||的区别

|与||的区别
相同点1 |与||的输出结果相同
相同点2 当符号左边为false时候,两者都会执行符号右边的运算
不同点 当符号左边是true的时候 |会继续执行右边的运算而||不会执行

        boolean bl4 = true;
        //bl4 = false;
        int a4 = 10;
        if (bl4 || (a4++>0)){	//左边为true 右边不执行
            System.out.println("Tokyo");
        }else{
            System.out.println("Peking");
        }
        System.out.println(a4);	//a4的结果是10

5.2 &与&&的区别

相同点1 &与&&的输出结果相同
相同点2 当符号左边为true时候,两者都会执行符号右边的运算
不同点 当符号左边是false的时候 &会继续执行右边的运算而&&不会执行

boolean bl2 = true;
bl2 = false;
int a2 = 10;
if (bl2 && (a2++>0)){	//左边为false 右边不执行
    System.out.println("Tokyo");
}else{
    System.out.println("Peking");
}
System.out.println(a2);	//a2的打印结果为10

6、位运算符

位运算符操作的都是整型的数据
1、<<在一定范围内，每向左移动1位，相当于*2
2、>>在一定范围内，每向右移动1位，相当于/2
正和负数的方法一样

int i =21;
System.out.println("i << 2 :"+(i << 2));	//相当于 21*2^2
System.out.println("i << 3 :"+(i << 3));	//相当于 21*2^3
System.out.println("i << 26 :"+(i << 26));	//下面以此类推
System.out.println("i << 27 :"+(i << 27));

System.out.println("i >> 2 :"+(i >> 2));	//相当于 21/2^2
System.out.println("i >> 26 :"+(i >> 26));	//下面以此类推

6.1 如何高效率计算 2*8

int y = 2<<3;	//相当于2*2^3
System.out.println(y);
int y1 = 8<<1;	//相当于8*2^1
System.out.println(y1);

6.2 面试题

面试题：请自己实现两个整数变量的交换
解答：首先我们要知道，位异或的特点，一个数据对另一个数据异或两次，该数本身不变。
代码如下：

//位运算符的实现
int x=5;
int y=10;
x=x^y; //5^10
y=x^y; //5^10^10
x=x^y; //5^10^5
System.out.println(x);
System.out.println(y);
print result: 10 5
//temp转换的实现(开发中更常用，效率更高)
int x1 = 15;
int y1 =20;
int temp = x1;
x1 = y1;
y1 = temp
System.out.println(x1);
System.out.println(y1);
print result: 20 15

7、三元运算符

格式
(条件表达式)? 表达式1：表达式2
为true，运算后的结果是表达式1
为false，运算后的结果是表达式2
表达式1、2为同种类型

int result = (a > b)? a: b;

7.1 获取两个整数的最大值

int a =10;
int b = 20;
int result = (a > b) ? a : b;
System.out.println("最大值是: "+result);

String result2 = (a > b) ? "a大" : "b大";
System.out.println("谁大: "+result);

a +=10;
// 俄罗斯套娃。。。。。。。。。。。。。。。
String result3 =(a > b) ? "a小" :((a == b) ? "相等" : "a大");

7.2 获取三个整数的最大值

int a =10;
int b = -90;
int c = 34;
int max = (a > b) ? a : b;
int max2 = (max > c) ? max : c;
System.out.println("最大的是： "+max2);

7.3 三元运算符和if-else的联系和区别

1、凡是可以用三元运算符的地方，都可以改写为if-else语句
反之，不成立。
2、如果程序既可以使用三元又可以使用if-else
优先使用三元效率更高。

8、运算符的优先级

所谓优先级就是表达式运算中的运算顺序。如图所示，上一行运算符总优先于下一行。
只有单目运算符，三元运算符，赋值运算符是从右向左运算的。
Attention:实际中的优先级完全取决于你，加上（）即可