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

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

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

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

代码执行后i、j、k分别等于多少呢？还是很简单？好，再继续：
Java代码
1. int i=0;   
2. System.out.println(i++); 
int i=0;
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++; 
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两次的值相加的结果1+2=3赋给j，因此这行代码运行完毕后i=2、j=3；对于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. } 
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。在解释按位运算符的执行原理时，我们顺便说说它们和逻辑运算符的区别。

[list=1]
  逻辑运算符只能操作布尔值或者一个能产生布尔值的表达式；按位运算符能操作整型值，包括byte、short、int、long，但是不能操作浮点型值（即float和double），它还可以操作字符型（char）值。按位运算符不能够操作对象，但是在Java5.0及以上版本中，byte、short
、int、long、char所对应的包装器类是个例外，因为JAVA虚拟机会自动将它们转换为对应的基本类型的数据。
下面的例子验证了这条规律：
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. } 
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));
        // 浮点型
in运算符的含义
        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
  逻辑运算符的运算遵循短路形式，而按位运算符则不是。所谓短路就是一旦能够确定运算的结果，就不再进行余下的运算。下面的例子更加直观地展现了短路与非短路的区别：
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();   

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。