java运算符.docx

java运算符.docx

《java运算符.docx》由会员分享，可在线阅读，更多相关《java运算符.docx（16页珍藏版）》请在冰豆网上搜索。

java运算符

前言

运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算。

JAVA中常见的运算符有很多种，大致分为以下几种，常见的几种运算符如下图：

算术运算符

加、减、乘、除、求余。

例++、--、%、/、 

赋值运算符

为变量或常量起到赋值作用的。

例如=、+=、*=

关系运算符

判断数据大小的，结果为一个布尔值。

例如>、>=、！

=、==

逻辑运算符

进行逻辑运算，运算的成员为布尔值，结果也为布尔值。

例如&&、||、！

。

条件运算符

也称三目运算符，表达式为（a

a:

b

位运算符

对二进制进行操作的，例如&、|、^、~、

一、算术运算符

1.1、常见的算术运算符

+

加法运算；例如x+y

-

减法运算；例如x-y

*

乘法运算；例如x*y

/

除法运算；例如x/y10/3=3;10/2.0=5.0

%

取模运算（求余运算）;例如x%y 10%3=1

++

自增运算；例如x++，++x

--

自减运算；例如x--，--x

1.2、算术运算中的类型转换

 运算时，运算结果会向数据类型大的转换；

在运算时，byte、short、char类型先自动转换为int类型

@Test

publicvoida（）{

inta=3;

doubleb=4;

System.out.println（a+b）;//输出7.0

floatc=3.2f;

/*c=c+3.14;编译错误,运算之后变为double类型*/

bytea1=3;

byteb1=4;

/*bytec1=a+b;

*编译错误,此处由于byte类型参与运算时，先直接转换为int类型，

*所以最后的结果也是int类型，但是得出的结果不能叫做int类型的直接量，所以编译错误

**/

intd1=a1+b1;

}

1.3、关于i++与++i的区别

∙i++是++在后，所以先用了再加

∙++i是++在前，所以先加了再用

注意点：

a+++b与a+++b的区别 a+++b的含义是（a++）+b;而a+++b的含义为a+（++b）

@Test

publicvoidb（）{

inta=1;

intb=1;

System.out.println（a++）;//输出1

System.out.println（++b）;//输出2

inta1=10;

intb1=10;

intsum=a1+++b1;

System.out.println（a1）;//输出11

System.out.println（b1）;//输出10

System.out.println（sum）;//输出20

inta2=10;

intb2=10;

intsum1=a2+++b2;

System.out.println（a2）;//输出10

System.out.println（b2）;//输出11

System.out.println（sum1）;//输出21

}

二、赋值运算符

2.1、常见的赋值运算符

运算符

含义

举例

=

等于

c=a+b就是将a+b的值赋给c

+=

加等于

a+=1等价于a=a+1

-=

减等于

a-=1等价于a=a-1

*=

乘等于

a*=b等价于a=a*b

/=

除等于

a/=b等价于a=a/b

%=

求余等于

a%=b等价于a=a%b

2.2、关于a+=1与a=a+1的区别

虽然在上面说的a+=1是等价于a=a+1，但是他们两还是有区别的。

@Test

publicvoidc（）{

bytea=1;

/*a=a+1;

*这里会报编译错误，由于a+1出现类型转换，变为int类型，所以再赋值给byte类型所以编译错误

**/

a+=1;

/*这里是不会出现编译错误的，这就是它的特殊之处

**/

System.out.println（a）;//输出2

byteb=127;

b+=1;

System.out.println（b）;

//输出-128，所以其实就是b=（byte）（b+1）;b+1为128，超出byte类型的范围，数据溢出为-128

}

原因：

+=运算符，是java语言规定的一元运算符（这里我将它归为赋值运算符有些不妥），Java有自动转换机制，java编译器会对其进行特殊处理，默认的向右转换类型，不需要人工转换。

2.3、各种赋值运算符的例子

@Test

publicvoidd（）{

inta=10;

doubleb=10;

System.out.println（a+=b）;

//输出20a=（int）（a+b）=（int）（10+10）=20

System.out.println（b+=a）;

//输出30.0b=a+b;double类型大，所以不需要自动转换b=20+10=30.0

inta1=10;

intb1=10;

System.out.println（a1*=b1）;//输出100

System.out.println（a1/=b1）;//输出10

System.out.println（a1%=b1）;//输出0

System.out.println（a1-=b1）;//-10

}

三、关系运算符

3.1常见关系运算符

关系运算符有时候也称为比较运算符，运算的结果一定为布尔值

符号

含义

举例

>

判断是否大于

booleana=3>2; a=true

<

判断是否小于

booleana=3<2; a=false

>=

判断是否大于等于

booleana=3<=3; a=true

<=

判断是否小于等于

booleana=3>=4; a=fasle

==

判断是否等于

booleana=3==4; a=false

！

=

判断是否不等于

booleana=3!

=4; a=true

注意点：

1.<、>、>=、<=只能比较数值类型，所以不能比较布尔类型和大多数应用类型，但是有些基本数据类型包装类型可以。

2.==、！

=既能比较基本数据类型，也能比较引用数据类型。

但是在比较引用数据类型的时候比较的就是地址了。

@Test

publicvoide（）{

inta1=10;

intb1=10;

booleana2=false;

booleanb2=false;

Integera3=10;

Integerb3=10;

Aa4=newA（）;

Ab4=newA（）;

System.out.println（a1>b1）;

/*System.out.println（a2>b2）;非数值类型不能比较大小*/

System.out.println（a3>b3）;

/*System.out.println（a4>b4）;不能比较大小*/

System.out.println（a1==b1）;

System.out.println（a2==b2）;//true

System.out.println（a3==b3）;

//相等，由于基本数据类型包装类Integer的自动装箱的特性，直接从静态数组中取的，所以不是new的

System.out.println（a4==b4）;

//false，由于是new出来的不等

}

3.2、==与equals的区别

首先我们要知道，equals方法是Object类中的一个方法，而Object类是所有类的父类。

首先我们先看一下Object类中equals方法的源代码：

publicbooleanequals（Objectobj）{

return（this==obj）;

}

可以看出Object类中该方法的逻辑就是==，所以Object类中给出的equals方法就是判断是否==；

那我们再看一下String类的equals方法，如下图：

publicbooleanequals（ObjectanObject）{

if（this==anObject）{

returntrue;

}

if（anObjectinstanceofString）{

StringanotherString=（String）anObject;

intn=value.length;

if（n==anotherString.value.length）{

charv1[]=value;

charv2[]=anotherString.value;

inti=0;

while（n--!

=0）{

if（v1[i]!

=v2[i]）

returnfalse;

i++;

}

returntrue;

}

}

returnfalse;

}

可以看出，String类中的equals不再是简简单单的直接判断==；它的equals方法是先判断它们是否==，如果不等再判断两个引用是否为同类或父子类关系，是的话再判断是否值一样，一样则返回true，否则返回fasle。

所以使用equals方法时要看该引用对应的类的equals方法的实现逻辑，一般情况下是String的话就是先比较地址，地址相等就为true，不为再比较内容，内容一样也是为true。

所以==与equals的区别可以总结为以下几点：

==是既能比较基本数据类型，比较基本数据类型的时候比较的是值是否相等。

又能比较引用数据类型，比较引用数据类型比较的是引用对应的地址是否相等。

而equals是一个方法，所以只能用来比较引用数据类型，要根据类中该方法实现的逻辑是什么来看比较的是什么。

一般情况下就是String类型和自定义的类。

对应String类型是判断内容是否一致。

可以看出，String类中的equals不再是简简单单的直接判断==；它的equals方法是先判断它们是否==，如果不等再判断两个引用是否为同类或父子类关系，是的话再判断是否值一样，一样则返回true，否则返回fasle。

所以使用equals方法时要看该引用对应的类的equals方法的实现逻辑，一般情况下是String的话就是先比较地址，地址相等就为true，不为再比较内容，内容一样也是为true。

所以==与equals的区别可以总结为以下几点：

==是既能比较基本数据类型，比较基本数据类型的时候比较的是值是否相等。

又能比较引用数据类型，比较引用数据类型比较的是引用对应的地址是否相等。

而equals是一个方法，所以只能用来比较引用数据类型，要根据类中该方法实现的逻辑是什么来看比较的是什么。

一般情况下就是String类型和自定义的类。

对应String类型是判断内容是否一致。

四、逻辑运算符

4.1、常用逻辑运算符

 首先逻辑运算符运算的对象必须还是布尔值，即符号两边必须是布尔类型。

运算符名称举例

&&与a&&b,a和b都为true，结果才为true，否则为false

||或a||b，a和b都为false，结果才为false，否则为true

!

非!

a，a为false，则结果为true。

即结果相反

变量a变量ba&&ba||b!

a

truetruetruetruefalse

truefalsefalsetruefalse

falsefalsefalsefalsetrue

falsetruefalsetruetrue

4.2、关于逻辑运算符中"短路"的问题

1.对于&&而言，当第一个操作数为false时，将不会判断第二个操作数。

2.对于||而言，当第一个操作数为true是，将不会判断第二个操作数。

@Test

publicvoidg（）{

inta=10;

intb=10;

booleanc=a>10&&b++>10;

System.out.println（c）;

System.out.println（b）;//输出10，由于a>10已经为False之后，后面的b++也就不会执行

booleand=a<11||b++>10;

System.out.println（d）;

System.out.println（b）;//也是输出10，前面的a<11已经为true，所以后面的b++也不执行

}

五、条件运算符

 即为三目运算符，形式为：

布尔表达式？

表达式1：

表达式2  

运算过程：

如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值

用处：

和ifelse的分支结构作用有点类似。

但是写法比ifelse简洁。

@Test

publicvoidh（）{

int[]a={-1,2,0};

for（inti=0;i

a[i]=a[i]>=0?

a[i]:

0;//将数组中小于0的数字变为0

}

for（intb:

a）{

System.out.println（b）;//利用增强for循环输出数组中的值

}

}

六、位运算符

6.1、常用位运算符

符号

含义

&

按位与

|

按位或

~

非（取反运算符）

^

异或

<<

左移运算符

>>

右移运算符

>>>

无符号右移运算符

6.2、按位与&详解

    按位与'&'与逻辑与'&&'不同，逻辑与'&&'只能操作布尔类型的值，而按位与'&'不仅能操作布尔类型的值，还能操作整数型基本类型。

且按位与'&'不像逻辑与'&&'一样有短路效应。

操作布尔类型的值时，与逻辑与'&&'类似，也是见false则false，就是没有短路效应。

操作整数基本数据类型是，即将整数化为二进制，然后相同位上计算，相同位都是1则结果为1，否则为0

例如：

3&4

    3的二进制为  0000000000000011

    4的二进制为  0000000000000100

    则结果为     0000000000000000对应的二级制为0，所以3&4=0;

（1）按位与的常见作用：

清0，取一个数中的指定位数（例如取int类型值的低八位）

例如int类型变量a对应的二进制为0010000100001010，现在求它的低八位，也就是1010，就可以使用a&15 15对应的二进制为 0000000000001111 所以 ，a&15的结果就为0000000000001010

（2）判断一个数的奇偶性：

n&1==1?

”奇数”:

”偶数”

（3）面试题：

优化n%8          

解答：

n&7

原因：

对8取模（求余）运算的定义就是整除8后的余数，而对于8来说，这个余数恰好就是这个数的二进制表示的低3位； 因此对8取模等价于获取数据的低3位，这由恰好等价于 &7 的结果。

6.3、按位或|详解

 按位或'|'与逻辑或 '||'不同，逻辑与'||'只能操作布尔类型的值，而按位与'|'不仅能操作布尔类型的值，还能操作整数型基本类型。

且按位或 '|'不像逻辑或 '||'一样有短路效应。

操作布尔类型的值时，与逻辑或 '||'类似，也是见true则true，就是没有短路效应。

操作整数基本数据类型是，即将整数化为二进制，然后相同位上计算，只要有一个1就为1，否则结果为0

例如3|4

    3的二进制为  0000000000000011

    4的二进制为  0000000000000100

    则结果为     0000000000000111对应的二级制为7，所以3&4=7;

按位或的作用：

将一个数的某些位置变为1

6.4、按位非~详解

   也称为取反运算符，是一个一元运算符，所以只能对一个操作数进行操作。

按位非就是将各位数字取反，0变为1,1变为0；

例如  4的二进制为0000000000000100

所以~4的二进制为 11111111 1111 1011转换为是十进制为-5

   常见作用：

一个数的相反数=该数取反+1   例如4的相反数-4=~4+1=-5+1=-4

6.5、异或^详解

将数转换为二进制之后运算，然后不相同的结果就为1； 0^0=0 1^0=1 0^1=1 1^1=0

例子：

4的二进制为 0000000000000100

      5的二进制为 0000000000000110

    4^5的二级制为 0000000000000010转换为十进制为2

异或^的作用实例：

不适用临时变量交换两个数

 我们经常写变量交换时，是以如下，用了一个临时变量来交换的；

@Test

publicvoida（）{

inta=3;

intb=4;

intc;//定义的临时变量

c=a;

a=b;

b=c;

System.out.println（a）;//输出4

System.out.println（b）;//输出3

}

但是利用异或运算符不用使用临时变量

@Test

publicvoidb（）{

inta=3;

intb=4;

a=a^b;

b=b^a;//b=b^（a^b）->b=a

a=a^b;//a=（a^b）^（b^a）->a=b

System.out.println（a）;//输出4

System.out.println（b）;//输出3

}

6.6、左移、右移、无符号右移动

左移运算符<< ：

符号位不变，低位补0；

右移运算符>> ：

是低位溢出，符号位不变，并用符号位补溢出高位

无符号右移运算符>>>:

低位溢出，高位补0，注意，无符号右移（>>>）中的符号位（最高位）也跟着变，无符号的意思是将符号位当作数字位看待。

@Test

publicvoidc（）{

inta=4;

System.out.println（a<<2）;

/*0000000000000100a的二进制

*000000000000010000低位补两个0

*0000000000010000高位溢出，所以a<<2=8

**/

System.out.println（a>>2）;

/*0000000000000100

*000000000000000100符号位补高位

*0000000000000001低位溢出所以a>>2=1

**/

intb=-1;

System.out.println（b>>>1）;

/*1111111111111111

*01111111111111111右移一位，高位补0，

*0111111111111111低位溢出结果为2147483647

**/

}

七、各种运算符的优先级

  下图为java中各种运算符的优先级，可以记一下，但有时候不太清楚的时候就直接用括号（）吧！

运算符结合性

[] . （）（方法调用）从左向右

!

~++--+（一元运算）从右向左

* / %从左向右

+-从左向右

<<>>>>>从左向右

<<=>>=instanceof从左向右

==!

=从左向右

&从左向右

^从左向右

|从左向右

&&从左向右

||从左向右

?

:

从右向左

=从右向左