JAVA面试题解惑系列（十一）——这些运算符你是否还记得？

 

JAVA面试题解惑系列（十一）——这些运算符你是否还记得？

关键字: java 面试题 自增 自减 位运算符

作者：臧圩人（zangweiren）
网址：http://zangweiren.iteye.com

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

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

自增（++）和自减（--）运算符

我们先来回答几个问题吧：

int i = 0;
int j = i++;
int k = --i;

int i = 0;
int j = i++;
int k = --i;

这段代码运行后，i等于多少？j等于多少？k等于多少？太简单了？好，继续：

int i = 0;
int j = i++ + ++i;
int k = --i + i--;

int i = 0;
int j = i++ + ++i;
int k = --i + i--;

代码执行后i、j、k分别等于多少呢？还是很简单？好，再继续：

int i=0;
System.out.println(i++);

int i=0;
System.out.println(i++);

这段代码运行后输出结果是什么？0？1？

float f=0.1F;
f++;
double d=0.1D;
d++;
char c='a';
c++;

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. 它们的运算结果的类型与被运算的变量的类型相同。

下面的这个例子验证以上列出的规律，它可以编译通过并执行。

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++;
    }
}

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虚拟机会自动将它们转换为对应的基本类型的数据。

下面的例子验证了这条规律：


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));
    }
}

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. 逻辑运算符的运算遵循短路形式，而按位运算符则不是。所谓短路就是一旦能够确定运算的结果，就不再进行余下的运算。
下面的例子更加直观地展现了短路与非短路的区别：


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();
    }
}

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。

下面的测试代码验证了以上的规律：

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)));
    }
}

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

下一期预告：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虚拟机汇编语言中关于赋值语句的解释很独特。。

[e-mail] 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   回复

什么时候给我们讲讲接口和内部类方面的知识啊？