Java中的运算符

一、算术运算符

整数运算：
若两个操作数中有一个为long,则结果为long,
如果没有long，则结果为int，即使两个操作数全为byte或者short。

浮点数运算：
若两个操作数有一个为double,则结果为double,
只有两个都为float时，结果才为float。

*+加       -减       乘       /除       %取模        ++自增       --自减       +字符串拼接

int i = 5210 / 1000 * 1000; //i = 5000;

注意

1、 Java是一只中强类型的语言，对于每种数据都严格划分了数据类型，整数运算完成之后结果一定是整数。

2、byte和short类型在计算的时候，底层会自动提升为int类型，然后进行计算。

byte b = 3 + 4  //相当于把int赋给了byte，可正常编译运行
//（这种写法只适合范围没有超出byte，一旦超过，就必须进行强制转换）

byte b1 = 3;  
byte b3 = b1 + 4;   //编译报错

byte b = 2;  
byte b1 = 3;  
byte b3 = b + b1; //(b+b1结果都是int类型的) ，编译报错 

改为(byte)(b+b1) 及正常

3、对于byte b = 3 + 4,JVM在编译的时候，会进行优化，编译完成之后，实际上这句话已经成了byte b = 7。

byte b = 127 + 3;  //编译报错（超出了byte的表数范围，必须进行强制类型转换）

byte b = 127;  
byte b1 = 4;  
byte b2 =(byte)( b + b1);  //编译运行正常

4、 整数除以0的时候，编译通过，运行报错—ArimeticException—算术异常

5、小数除以0的结果是Infinity

6、0/0.0的结果是NaN—Not a Number—非数字

7、byte/short类型在运算的时候会自动提升为int类型

%取余运算

-5%3;  //结果为：-2
-4%3;  //结果为：1
-3%7;  //结果为：-3
5%-3;  //结果为：2
7%-2;  //结果为：1
2%-8;  //结果为：2
-5%-3;  //结果为：-2
-9%-3;  //结果为：0

对于负数的取余，先按照正数的取余运算，看取余符号左边的数字的符号，如果左边是负数，那么结果就是负数

5%1.2;  //结果为：0.2
6%1.3; //结果为：0.8
4.3%1.4; //结果为：0.1

++自增/–自减

对于++在原来的基础上自增1
只有自增运算的时候，++在前在后结果都是一样。
++在前，这个变量先自增，然后参与其他的运算，++在后，先参与其他运算，再自增。

int i = 5;
int j = ++i; // i自增1，然后将i的值赋值给j---先自增，再运算
int j = i++; //先获取i的值5，i自增成6，然后将获取的值5赋值给j---先运算，再自增

int i = 3;    
int j = ++i * 2;   // 结果：j = 8;

int i = 3;    
int j = i++ * 2;  //结果：j = 6

int i = 6;    
int j = i++ + ++i;    //结果：i = 8;  j = 14;

int i = 6;  
int j = ++i + i++;     //结果：i = 8; j = 14  

byte b = 5;
b++; //JVM在底层会对结果进行强制类型转换，将结果再转换为byte类型

char c = 'a';        
System.out.println(c + 4);
//正常  char + int 结果是int类型。

char c2 = 'd';      
System.out.println(c + c2);
//提升为int类型之后再进行运算

+ 字符串拼接运算

"a" + "b" // "ab"
"a"  + 3 //"a3"
"a" + true //"atrue"
2 + 4 + "f" //"6f"
"f" + 2 + 4 //"f24"

二、 赋值运算符

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

int i= 5;
i += 3; //i = i + 3; -> i = 8;
i -= 2;	//i = i - 2; -> i = 3;
int j;
j += 4; //编译错误，j需要初始化

除了=以外的赋值运算符，在使用的时候必须要初始化。

(面试的时候，会经常出错的题目。。。仔细计算)

int i = 5;   
i += i -= i *= 5;	//i = -15;   i = 5 + ( 5 - (5 * 5)) ;

int i = 5;   
i += i -= i *= ++i;     // i = -20;

int i = 5;   
i += i*= i-= (i++ + --i); // i = -20;i = 5 + ( 5 * (5 - (5 + 5)));

int i = 5;   
i += i-= i *= i++;   // i=15

int i = 5;   
 i += i-= i *= i++ * 2; // i=-40

byte b = 5;     b += 3;	//正常
byte b = 125;   b += 3; //正常--- -128  （底层自动转换）

三、 比较/关系运算符

      ==相等        !=不等        >       <       >=        <=       instanceof

nstanceof：判断对象与类的关系，判断某个对象是否是某个类的实例，判断的是实际类型，也就是new的时候用的是什么就是什么（只能用于引用数据类型。）

String s = "abd";
System.out.println(s instanceof String); //true
System.out.println("def" instanceof String); //true

四、逻辑运算符

用于运算逻辑值
      &与And      |或OR      !非 NOT       ^异或      &&短路与      ||短路或

true&false;	//false 
true&true;	//true 
false&true;	//false 
false&false;	//false
true|true;	//true 
true|false;	//true 
false|true;		//true 
false|false;	//false
!true;	//false 
!false; 	//true
true^true //false 
true^false //true 
false^true	//true 
false^false 	//false

（异或：相同为true，相异为false）

      对于&&，运算规则与&完全一样。但是==&&有短路的特性==，而&是没有短路特性的： 如果前一个表达式的值为false，那么就能确定整个表达式的值为false，&&后边的运算就不再进行了
      对于||，运算规则与|完全一样。但是==||有短路的特性==，而 | 是没有短路特性的：如果前一个表达式的值为true，那么就能确定整个表达式的值为true，||后边的运算就不再进行了.

五、位运算符

&按位与       |按位或        ^按位异或        <<左移        >> 右移       >>>无符号右移       ~取反

       &运算规律：将数字转化成二进制之后，低位对齐，高位次不足补0，将1看做true，将0看做false,然后按位与操作，将结果转化为十进制显示。
       |运算规律：将数字转化成二进制之后，低位对齐，高位次不足补0，将1看做true，将0看做false,然后按位或操作，将结果转化为十进制显示。
      ^运算规律：将数字转化成二进制之后，低位对齐，高位次不足补0，将1看做true，将0看做false,然后按位异或操作，将结果转化为十进制显示。
奇数^偶数= 奇数
奇数^ 偶数= 奇数 奇数^ 奇数= 偶数 偶数^偶数= 偶数

a^ b^b=a

交换值的方法（三种）：

方式一：借助第三方变量（用的最多的方法,可以交换任何类型的值，可阅读性更高）

int i=3 , j = 4, temp;
temp = i;
i = j;
j = temp;

方式二：利用加减法（可以用于运算数值型但是不能用于交换其他类型的值例如字符串类型）

int i = 3, j = 4;
i = i + j;
j = i - j;  // i+j-j=i
i = i - j;  // i+j-i=j

i +=j; j = i - j; i-=j; 面试的时候一般都是用的是这种简写形式。

方式三：异或运算 效率最高的方法（直接操作的是二进制），但是使用的较少（因为有局限性。位运算只是针对整数进行的，其他类型就不能用了）

int i = 3, j = 4;
i = i ^j;  
j = i ^j;  //j=i^j^j=i
i = i ^j;  //i=i^j^i=j

i ^ =j; j^=i; i ^ =j；面试的时候一般都是用的是这种简写形式。

<<左移：运算规律：将数据转化为二进制之后，按照指定的位数进行左移。移除的部分舍弃，低位次空出补0，然后将数据转化为十进制转换。（byte左移以后是int类型。除了++、+=等类似的运算还是本身，其余运算之后成为int类型）

一个数字左移几位，就是将这个数乘以2的几次方，然后取整。
在一定范围内，左移是越移越大。

> > 右移:运算规律：将数据转化为二进制之后，按照指定的位数进行右移。移除的部分舍弃，高位次空出整数补0，负数补1，然后将数据转化为十进制转换。
正数右移，越移越小，最小到0， 负数右移，越移越大，最大为-1
一个数字右移几位，就是将这个数除以2的几次方，然后取整。

> > > 无符号右移：
和右移类似，但是最高位空出之后，无论正数还是负数一律补0.

~ 取反运算规则：将数字转化成二进制之后，1变0，0变1，最高位看成-128，其余位按照二进制向十进制转化规则计算，然后加上-128.（-128说明是个byte类型）~i = -i - 1