这些运算符你是否还记得？

（十一）这些运算符你是否还记得？
关键字: java 面试题 自增 自减 位运算符
作者：臧圩人（zangweiren） 发布时间：2008-08-25
网址：http://zangweiren.javaeye.com
>>>转载请注明出处！<<<
有些运算符在 JAVA 语言中存在着，但是在实际开发中我们或许很少用到它们，在面试题中
却时常出现它们的身影，对于这些运算符的含义和用法，你是否还记得呢？
自增（++）和自减（--）运算符
我们先来回答几个问题吧：
Java 代码
int i = 0;
int j = i++;
int k = --i;
这段代码运行后，i 等于多少？j 等于多少？k 等于多少？太简单了？好，继续：
Java 代码
int i = 0;
int j = i++ + ++i;
int k = --i + i--;
代码执行后 i、j、k 分别等于多少呢？还是很简单？好，再继续：
Java 代码
int i=0;
System.out.println(i++);
这段代码运行后输出结果是什么？0？1？
Java 代码
float f=0.1F;
f++;
double d=0.1D;
d++;
char c='a';
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 代码
public class Test {
public static void main(String[] args) {
// 整型
byte b = 0;
b++;
// 整型
long l = 0;
l++;
// 浮点型
double d = 0.0;
d++;
// 字符串
char c = 'a';
c++;
// 基本类型包装器类
Integer i = new Integer(0);
i++;
}
}
按位运算符
你还能说出来按位运算符一共有哪几种吗？对比下面的列表看看，有没有从你的记忆中消失
了的：
 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 虚拟机会自动将它们转换为
对应的基本类型的数据。
 下面的例子验证了这条规律：
 Java 代码
public class BitOperatorTest {
 public static void main(String[] args) {
 // 整型
 byte b1 = 10, b2 = 20;
 System.out.println("(byte)10 & (byte)20 = " + (b1 & b2));
 // 字符串型
 char c1 = 'a', c2 = 'A';
 System.out.println("(char)a | (char)A = " + (c1 | c2));
 // 基本类型的包装器类
 Long l1 = new Long(555), l2 = new Long(666);
 System.out.println("(Long)555 ^ (Long)666 = " + (l1 ^ l2));
 // 浮点型
 float f1 = 0.8F, f2 = 0.5F;
 // 编译报错，按位运算符不能用于浮点数类型
 // System.out.println("(float)0.8 & (float)0.5 = " + (f1 & f2));
 }
 }

 运行结果：
• (byte)10 & (byte)20 = 0
• (char)a | (char)A = 97
• (Long)555 ^ (Long)666 = 177
 2. 逻辑运算符的运算遵循短路形式，而按位运算符则不是。所谓短路就是一旦能够确定
运算的结果，就不再进行余下的运算。
 下面的例子更加直观地展现了短路与非短路的区别：
 Java 代码
public class OperatorTest {
 public boolean leftCondition() {
 System.out.println("执行-返回值:false;方法:leftCondition()");
 return false;
 }
 public boolean rightCondition() {
 System.out.println("执行-返回值:true;方法:rightCondition()");
 return true;
 }
 public int leftNumber() {
 System.out.println("执行-返回值:0;方法:leftNumber()");
 return 0;
 }
 public int rightNumber() {
 System.out.println("执行-返回值:1;方法:rightNumber()");
 return 1;
 }
 public static void main(String[] args) {
 OperatorTest ot = new OperatorTest();
 if (ot.leftCondition() && ot.rightCondition()) {
 // do something
 }
 System.out.println();
 int i = ot.leftNumber() & ot.rightNumber();
 }
 }

 运行结果：
• 执行-返回值: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 代码
public abstract class Test {
public static void main(String[] args) {
System.out.println("1 << 3 = " + (1 << 3));
System.out.println("(byte) 1 << 35 = " + ((byte) 1 << (32 + 3)));
System.out.println("(short) 1 << 35 = " + ((short) 1 << (32 + 3)));
System.out.println("(char) 1 << 35 = " + ((char) 1 << (32 + 3)));
System.out.println("1 << 35 = " + (1 << (32 + 3)));
System.out.println("1L << 67 = " + (1L << (64 + 3)));
// 此处需要 Java5.0 及以上版本支持
System.out.println("new Integer(1) << 3 = " + (new Integer(1) << 3));
System.out.println("10000 >> 3 = " + (10000 >> 3));
System.out.println("10000 >> 35 = " + (10000 >> (32 + 3)));
System.out.println("10000L >>> 67 = " + (10000L >>> (64 + 3)));
}
}
运行结果：
 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

转载于:https://www.cnblogs.com/JimCalark/p/6931146.html