CSDN博客

img zhq426

JAVA面试题解惑系列(十一)——这些运算符你是否还记得?

发表于2008/9/28 14:50:00  635人阅读

 

JAVA面试题解惑系列(十一)——这些运算符你是否还记得?

关键字: java 面试题 自增 自减 位运算符
作者:臧圩人(zangweiren)
网址:http://zangweiren.javaeye.com

>>>转载请注明出处!<<<

有些运算符在JAVA语言中存在着,但是在实际开发中我们或许很少用到它们,在面试题中却时常出现它们的身影,对于这些运算符的含义和用法,你是否还记得呢?

自增(++)和自减(--)运算符

我们先来回答几个问题吧:
Java代码 复制代码
  1. int i = 0;  
  2. int j = i++;  
  3. int k = --i;  

这段代码运行后,i等于多少?j等于多少?k等于多少?太简单了?好,继续:
Java代码 复制代码
  1. int i = 0;  
  2. int j = i++ + ++i;  
  3. int k = --i + i--;  

代码执行后i、j、k分别等于多少呢?还是很简单?好,再继续:
Java代码 复制代码
  1. int i=0;  
  2. System.out.println(i++);  

这段代码运行后输出结果是什么?0?1?
Java代码 复制代码
  1. float f=0.1F;  
  2. f++;  
  3. double d=0.1D;  
  4. d++;  
  5. char c='a';  
  6. c++;  

上面这段代码可以编译通过吗?为什么?如果你能顺利回答到这里,说明你对自增和自减运算符的掌握已经很好了。

为了分析出上面提出的几个问题,我们首先来回顾一下相关知识:
  • 自增(++):将变量的值加1,分前缀式(如++i)和后缀式(如i++)。前缀式是先加1再使用;后缀式是先使用再加1。
  • 自减(--):将变量的值减1,分前缀式(如--i)和后缀式(如i--)。前缀式是先减1再使用;后缀式是先使用再减1。

在第一个例子中,int j=i++;是后缀式,因此i的值先被赋予j,然后再自增1,所以这行代码运行后,i=1、j=0;而int k=--i;是前缀式,因此i先自减1,然后再将它的值赋予k,因此这行代码运行后,i=0、k=0。

在第二个例子中,对于int j=i++ + ++i;,首先运行i++,i的值0被用于加运算(+),之后i自增值变为1,然后运行++i,i先自增变为2,之后被用于加运算,最后将i两次的值相加 的结果0+2=2赋给j,因此这行代码运行完毕后i=2、j=2;对于int k=--i + i--;用一样的思路分析,具体过程在此不再赘述,结果应该是i=0、k=2。

自增与自减运算符还遵循以下规律:
  1. 可以用于整数类型byte、short、int、long,浮点类型float、double,以及字符串类型char。
  2. 在Java5.0及以上版本中,它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。
  3. 它们的运算结果的类型与被运算的变量的类型相同。

下面的这个例子验证以上列出的规律,它可以编译通过并执行。
Java代码 复制代码
  1. public class Test {  
  2.     public static void main(String[] args) {  
  3.         // 整型  
  4.         byte b = 0;  
  5.         b++;  
  6.         // 整型  
  7.         long l = 0;  
  8.         l++;  
  9.         // 浮点型  
  10.         double d = 0.0;  
  11.         d++;  
  12.         // 字符串  
  13.         char c = 'a';  
  14.         c++;  
  15.         // 基本类型包装器类  
  16.         Integer i = new Integer(0);  
  17.         i++;  
  18.     }  
  19. }  


按位运算符

你还能说出来按位运算符一共有哪几种吗?对比下面的列表看看,有没有从你的记忆中消失了的:
  1. 按位与运算(&):二元运算符。当被运算的两个值都为1时,运算结果为1;否则为0。
  2. 按位或运算(|):二元运算符。当被运算的两个值都为0时,运算结果为0;否则为1。
  3. 按位异或运算(^):二元运算符。当被运算的两个值中任意一个为1,另一个为0时,运算结果为1;否则为0。
  4. 按位非运算(~):一元运算符。当被运算的值为1时,运算结果为0;当被运算的值为0时,运算结果为1。

这里不像我们看到的逻辑运算符(与运算&&、或运算||、非运算!)操作的是布尔值true或false,或者是一个能产生布尔 值的表达式;“按位运算符”所指的“位”就是二进制位,因此它操作的是二进制的0和1。在解释按位运算符的执行原理时,我们顺便说说它们和逻辑运算符的区 别。

  1. 逻辑运算符只能操作布尔值或者一个能产生布尔值的表达式;按位运算符能操作整型值,包括byte、short、int、long,但是不能操作浮 点型值(即float和double),它还可以操作字符型(char)值。按位运算符不能够操作对象,但是在Java5.0及以上版本中,byte、 short、int、long、char所对应的包装器类是个例外,因为JAVA虚拟机会自动将它们转换为对应的基本类型的数据。

  2. 下面的例子验证了这条规律:
    Java代码 复制代码
    1. public class BitOperatorTest {  
    2.     public static void main(String[] args) {  
    3.         // 整型  
    4.         byte b1 = 10, b2 = 20;  
    5.         System.out.println("(byte)10 & (byte)20 = " + (b1 & b2));  
    6.         // 字符串型  
    7.         char c1 = 'a', c2 = 'A';  
    8.         System.out.println("(char)a | (char)A = " + (c1 | c2));  
    9.         // 基本类型的包装器类  
    10.         Long l1 = new Long(555), l2 = new Long(666);  
    11.         System.out.println("(Long)555 ^ (Long)666 = " + (l1 ^ l2));  
    12.         // 浮点型  
    13.         float f1 = 0.8F, f2 = 0.5F;  
    14.         // 编译报错,按位运算符不能用于浮点数类型  
    15.         // System.out.println("(float)0.8 & (float)0.5 = " + (f1 & f2));  
    16.     }  
    17. }  

    运行结果:
    • (byte)10 & (byte)20 = 0
    • (char)a | (char)A = 97
    • (Long)555 ^ (Long)666 = 177
  3. 逻辑运算符的运算遵循短路形式,而按位运算符则不是。所谓短路就是一旦能够确定运算的结果,就不再进行余下的运算。
  4. 下面的例子更加直观地展现了短路与非短路的区别:
    Java代码 复制代码
    1. public class OperatorTest {  
    2.     public boolean leftCondition() {  
    3.         System.out.println("执行-返回值:false;方法:leftCondition()");  
    4.         return false;  
    5.     }  
    6.   
    7.     public boolean rightCondition() {  
    8.         System.out.println("执行-返回值:true;方法:rightCondition()");  
    9.         return true;  
    10.     }  
    11.   
    12.     public int leftNumber() {  
    13.         System.out.println("执行-返回值:0;方法:leftNumber()");  
    14.         return 0;  
    15.     }  
    16.   
    17.     public int rightNumber() {  
    18.         System.out.println("执行-返回值:1;方法:rightNumber()");  
    19.         return 1;  
    20.     }  
    21.   
    22.     public static void main(String[] args) {  
    23.         OperatorTest ot = new OperatorTest();  
    24.   
    25.         if (ot.leftCondition() && ot.rightCondition()) {  
    26.             // do something  
    27.         }  
    28.         System.out.println();  
    29.   
    30.         int i = ot.leftNumber() & ot.rightNumber();  
    31.     }  
    32. }  

    运行结果:
    • 执行-返回值:false;方法:leftCondition()

    • 执行-返回值:0;方法:leftNumber()
    • 执行-返回值:1;方法:rightNumber()

    运行结果已经很明显地显示了短路和非短路的区别,我们一起来分析一下产生这个运行结果的原因。当运行“ot.leftCondition() && ot.rightCondition()”时,由于方法leftCondition()返回了false,而对于“&&”运算来说,必须 要运算符两边的值都为true时,运算结果才为true,因此这时候就可以确定,不论rightCondition()的返回值是什 么,“ot.leftCondition() && ot.rightCondition()”的运算值已经可以确定是false,由于逻辑运算符是短路的形式,因此在这种情况 下,rightCondition()方法就不再被运行了。
    而对于“ot.leftNumber() & ot.rightNumber()”,由于“leftNumber()”的返回值是0,对于按位运算符“&”来说,必须要运算符两边的值都是1 时,运算结果才是1,因此这时不管“rightNumber()”方法的返回值是多少,“ot.leftNumber() & ot.rightNumber()”的运算结果已经可以确定是0,但是由于按位运算符是非短路的,所以rightNumber()方法还是被执行了。这就 是短路与非短路的区别。

移位运算符

移位运算符和按位运算符一样,同属于位运算符,因此移位运算符的位指的也是二进制位。它包括以下几种:
  1. 左移位(<<):将操作符左侧的操作数向左移动操作符右侧指定的位数。移动的规则是在二进制的低位补0。
  2. 有符号右移位(>>):将操作符左侧的操作数向右移动操作符右侧指定的位数。移动的规则是,如果被操作数的符号为正,则在二进制的高位补0;如果被操作数的符号为负,则在二进制的高位补1。
  3. 无符号右移位(>>>):将操作符左侧的操作数向右移动操作符右侧指定的位数。移动的规则是,无论被操作数的符号是正是负,都在二进制位的高位补0。

注意,移位运算符不存在“无符号左移位(<<<)”一说。与按位运算符一样,移位运算符可以用于byte、short、 int、long等整数类型,和字符串类型char,但是不能用于浮点数类型float、double;当然,在Java5.0及以上版本中,移位运算符 还可用于byte、short、int、long、char对应的包装器类。我们可以参照按位运算符的示例写一个测试程序来验证,这里就不再举例了。

与按位运算符不同的是,移位运算符不存在短路不短路的问题。

写到这里就不得不提及一个在面试题中经常被考到的题目:
引用
请用最有效率的方法计算出2乘以8等于几?

这里所谓的最有效率,实际上就是通过最少、最简单的运算得出想要的结果,而移位是计算机中相当基础的运算了,用它来实现准没错了。左移位 “<<”把被操作数每向左移动一位,效果等同于将被操作数乘以2,而2*8=(2*2*2*2),就是把2向左移位3次。因此最有效率的计算 2乘以8的方法就是“2<<3”。

最后,我们再来考虑一种情况,当要移位的位数大于被操作数对应数据类型所能表示的最大位数时,结果会是怎样呢?比如,1<<35=?呢?

这里就涉及到移位运算的另外一些规则:
  1. byte、short、char在做移位运算之前,会被自动转换为int类型,然后再进行运算。
  2. byte、short、int、char类型的数据经过移位运算后结果都为int型。
  3. long经过移位运算后结果为long型。
  4. 在左移位(<<)运算时,如果要移位的位数大于被操作数对应数据类型所能表示的最大位数,那么先将要求移位数对该类型所能 表示的最大位数求余后,再将被操作数移位所得余数对应的数值,效果不变。比如1<<35=1<<(35%32)=1<& lt;3=8。
  5. 对于有符号右移位(>>)运算和无符号右移位(>>>)运算,当要移位的位数大于被操作数对应数据类 型所能表示的最大位数时,那么先将要求移位数对该类型所能表示的最大位数求余后,再将被操作数移位所得余数对应的数值,效果不变。。比如 100>>35=100>>(35%32)=100>>3=12。

下面的测试代码验证了以上的规律:
Java代码 复制代码
  1. public abstract class Test {  
  2.     public static void main(String[] args) {  
  3.         System.out.println("1 << 3 = " + (1 << 3));  
  4.         System.out.println("(byte) 1 << 35 = " + ((byte1 << (32 + 3)));  
  5.         System.out.println("(short) 1 << 35 = " + ((short1 << (32 + 3)));  
  6.         System.out.println("(char) 1 << 35 = " + ((char1 << (32 + 3)));  
  7.         System.out.println("1 << 35 = " + (1 << (32 + 3)));  
  8.         System.out.println("1L << 67 = " + (1L << (64 + 3)));  
  9.         // 此处需要Java5.0及以上版本支持  
  10.         System.out.println("new Integer(1) << 3 = " + (new Integer(1) << 3));  
  11.         System.out.println("10000 >> 3 = " + (10000 >> 3));  
  12.         System.out.println("10000 >> 35 = " + (10000 >> (32 + 3)));  
  13.         System.out.println("10000L >>> 67 = " + (10000L >>> (64 + 3)));  
  14.     }  
  15. }  

运行结果:
  1. 1 << 3 = 8
  2. (byte) 1 << 35 = 8
  3. (short) 1 << 35 = 8
  4. (char) 1 << 35 = 8
  5. 1 << 35 = 8
  6. 1L << 67 = 8
  7. new Integer(1) << 3 = 8
  8. 10000 >> 3 = 1250
  9. 10000 >> 35 = 1250
  10. 10000L >>> 67 = 1250


下一期预告:JAVA面试题解惑系列(十二)——你真的了解数组吗?
评论
gouf 2008-09-06   回复
感谢
复习基础啦, 很多细节以前没注意到
夜行者 2008-08-29   回复
恩,不错啊,顶顶
wuchunhui 2008-08-29   回复
lin_llx 2008-08-29   回复
我想到以前看见过的一个关于Java与C++的++运算不同的文章。同样一段代码。
i=0;
i=i++;
print i;
Java里面,输出是0;
C++里面,输出是1;
貌似原因涉及到了Java虚拟机汇编语言中关于赋值语句的解释很独特。。
spaceflysky@163.com 2008-08-28   回复
好,好,好!!!
好好向楼主学习,天天向高手接近!!!
backbase 2008-08-28   回复
楼主又发布新文章了,让我们这些刚入职业的新手受益匪浅,辛苦了,谢谢楼主!永远支持你!
davepkxxx 2008-08-27   回复
我认为是不要研究那些比较容易混淆或者让人误会的书写方法
臧圩人 2008-08-27   回复
回复yellowteeth:

诚如wykris所理解的,我的本意是以面试题为出发点发散开来,总结与之相关的JAVA知识,与大家共享。任何人写文章都有其针对性与适用范围 的,我是就面试题讲JAVA知识,不是写入门教材,也并不是提倡大家按照面试题中出现的方式来编写代码。面试题只是一个载体,我们的目的不是会做更多的面 试题,而是能深刻理解面试题背后隐藏的知识。

非常感谢你的中肯意见,对于你屡次提到的这句话我深表赞同:
引用
我们应该把时间化在扩展你的知识面上,而不是这一些死板的细节和术语上。

臧圩人 2008-08-26   回复
CSDN网友wykris回复yellowteeth道:

开头第一句话:“有些运算符在JAVA语言中存在着,但是在实际开发中我们或许很少用到它们,在面试题中却时常出现它们的身影,对于这些运算符的含义和用法,你是否还记得呢? ”


这是面试题解惑系列……不是Java入门系列……
项目中用不到不代表笔试题里没有这种题,您明显回帖不看帖
臧圩人 2008-08-26   回复
CSDN网友yellowteeth写道:

zangweiren,我无意批评你这一贴,但我看有这么多人跟贴,并说要支持,我想不能再有初学者被误导了。我只是就事论事说一下:
其实我只看了第一题,我就不愿再向下看了,因为你写的让我想到了在学校的考试的题目,死板,没有实际的意义,所以我只看了一题,我再也不想向下看 了。我想你也应知道:当今编程的方向不是技术性,是可读性,和编译效率相比,程序的可读性的高于编译效率!除非编译效率有数量级的提高。

int j = i++ + ++i; 

这想有人会在实际开发中用这样的语句吗?你这样写的目的是什么?你可能会说:这样写程序运行效率会高一些。晕倒,你告诉我快多少?0.001秒? 有意思吗?可能过两年后你移值你的程序时,你自已都要化10分钟看这几句说的什么意思?或许还要看一下新版本的java下,这几句的编译的结果是不是你两 年前想要的效果?
我记得张老师说过的一句话:我们应该把时间化在扩展你的知识面上,而不是这一些死板的细节和术语上。

因为我深受过这种苦味,那时我初学c++,总是被这一类的语句j=i+++++i苦扰,当我以为我搞明白了后,发现换一个系统后,(java这方 法比以C++好多了)运行结果又不一样了,所以我觉得没有意思,还是用张老师的那句话结尾吧:我们应该把时间化在扩展你的知识面上,而不是这一些死板的细 节和术语上。
臧圩人 2008-08-26   回复
CSDN网友vlemfun写道:

实际操作了一下
运算结果和这个不一样

在第二个例子中,对于int j=i++ + ++i;,首先运行i++,i的值0被用于加运算(+),之后i自增值变为1,然后运行++i,i先自增变为2,之后被用于加运算,最后将i两次的值相加 的结果1+2=3赋给j,因此这行代码运行完毕后i=2、j=3;对于int k=--i + i--;用一样的思路分析,具体过程在此不再赘述,结果应该是i=0、k=2。


……
臧圩人 2008-08-26   回复
CSDN网友ZangXT写道:

尽量不要对除int和long之外的类型使用++运算符,可能带来隐含的错误。
臧圩人 2008-08-26   回复
回复h_yz、tcwt008、phz50:

感谢大家的支持,请多多关注,欢迎提意见
臧圩人 2008-08-26   回复
only_java 写道
什么时候给我们讲讲接口和内部类方面的知识啊?


后续的文章会讲到的,请继续关注
臧圩人 2008-08-26   回复
回复 君临天下:

感谢你又来捧场啊,呵呵
phz50 2008-08-26   回复
JAVA面试题解惑系列,每篇都很有文采,条理清楚,受益匪浅,非常感谢!
tcwt008 2008-08-26   回复
温故而知新!
君临天下 2008-08-26   回复
都写的不错啊
h_yz 2008-08-26   回复
谢谢楼主,真是好人,这么多我们不知道的JAVA知识,让小弟我大开眼见了呀
only_java 2008-08-26   回复
什么时候给我们讲讲接口和内部类方面的知识啊?
0 0

相关博文

我的热门文章

img
取 消
img