运算符

有些运算符在 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



联系我们 | 友情链接