操作符

 

既然已经学习了如何声明和初始化变量，或许你希望了解如何对变量进行某种操作。从Java编程语言的操作符开始学习是个好主意。操作符是特定的符号，可以使用它们对一个、两个或者三个操作数（operand）进行特定操作，然后返回结果。

在学习Java编程语言的操作符之前，首先了解哪些操作符具有最高优先级是有帮助的。表3-2中的操作符是按照它们的优先级顺序列出的。操作符出现的位置越靠近表的顶部，其优先级就越高。优先级高的操作符先于优先级相对低的操作符进行计算。位于同一行的操作符具有相同优先级。优先级相同的操作符出现在同一表达式中时，必须给出规则，从而确定先计算哪个操作符。除赋值操作符之外，所有二元操作符都按照从左到右的顺序计算；赋值操作符按照从右到左的顺序计算。

表3-2  操作符优先级

操作符

优先级

后缀

expr++ expr--

一元

++expr --expr +expr -expr ~ !

乘

* / %

（续）

操作符

优先级

加

+ -

移位

<< >> >>>

关系

< > <= >= instanceof

相等

== !=

按位与

&

按位异或

^

按位或

|

逻辑与

&&

逻辑或

||

三元

? :

赋值

= += -= *= /= %= &= ^= |= <<= >>= >>>=

在通用编程中，某些操作符出现的频率高于其他操作符；例如，赋值操作符“=”要比无符号右移位操作符“>>>”常见得多。了解这些之后，下面的讨论首先介绍最常用的操作符，然后介绍不怎么常见的操作符。后面的讨论都带有示例代码，你可以编译并运行它们。分析代码的输出能帮助你强化学到的知识。

3.2.1  赋值、算术和一元操作符

1. 简单的赋值操作符

你将用到的最常见的操作符之一是简单的赋值操作符“=”。在Bicycle类中已经见过了这个操作符；它把其右侧操作数的值赋给左侧操作数：

int cadence = 0;

int speed = 0;

int gear = 1;

也可以对对象使用这个操作符，进行对象引用（object reference）的赋值，这将在第8章中讨论。

2. 算术操作符

Java编程语言提供执行加法、减法、乘法和除法操作的操作符。在基本数学运算中能经常看到它们。你感觉陌生的唯一符号可能是“%”，它用一个操作数除另一个操作数，然后返回结果的余数。

+    加法操作符（也用于拼接字符串）

-    减法操作符

*    乘法操作符

/    除法操作符

%    取模操作符

下面的程序ArithmeticDemo测试算术操作符。

class ArithmeticDemo {

  public static void main (String[] args){

    int result = 1 + 2; // result is now 3

    System.out.println(result);

 

    result = result - 1; // result is now 2

    System.out.println(result);

    result = result * 2; // result is now 4

    System.out.println(result);

    result = result / 2; // result is now 2

    System.out.println(result);

    result = result + 8; // result is now 10

    result = result % 7; // result is now 3

    System.out.println(result);

  }

}

也可以把算术操作符和简单的赋值操作符组合在一起，从而创建复合赋值（compound assignment）。例如，x+=1;和x=x+1;都表示x的值加1。

“+”操作符也可以用于把两个字符串串联（连接）在一起，如下面的程序ConcatDemo所示：

class ConcatDemo {

  public static void main(String[] args){

    String firstString = "This is";

    String secondString = " a concatenated string.";

    String thirdString = firstString+secondString;

    System.out.println(thirdString);

  }

}

在程序的结尾，变量thirdString包含“This is a concatenated string.”，它被发送到标准输出。

3. 一元操作符

一元操作符只需要一个操作数；它们执行各种操作，比如使值递增/递减1、反转表达式或者对布尔值求反。

+     一元正操作符，指示正值（但不带这个操作符的数也是正的）

-     一元负操作符，对表达式求反

++     递增操作符，使值增加1

--    递减操作符，使值减去1

!     逻辑求补操作符，反转布尔值

下面的程序UnaryDemo测试一元操作符：

class UnaryDemo {

  public static void main(String[] args){

    int result = +1; // result is now 1

    System.out.println(result);

    result--; // result is now 0

    System.out.println(result);

    result++; // result is now 1

    System.out.println(result);

    result = -result; // result is now -1

    System.out.println(result);

    boolean success = false;

    System.out.println(success); // false

    System.out.println(!success); // true

  }

}

递增/递减操作符可以在操作数之前（前缀）或者之后（后缀）使用。代码result++;和++result;都将使result加1。唯一的区别在于，前缀版本（++result）对增加后的值进行计算；而后缀版本（result++）对原始值进行计算。如果你仅仅执行简单的递增/递减操作，那么选择哪个版本就没什么关系。但是如果使用这个操作符作为更大的表达式的一部分，那么选择不同版本就会造成很大区别。

下面的程序PrePostDemo演示前缀／后缀版本的一元递增操作符：

class PrePostDemo {

  public static void main(String[] args){

    int i = 3;

    i++;

    System.out.println(i);   // "4"

    ++i;

    System.out.println(i);   // "5"

    System.out.println(++i); // "6"

    System.out.println(i++); // "6"

    System.out.println(i);   // "7"

  }

}

3.2.2  相等、关系和条件操作符

1. 相等和关系操作符

相等和关系操作符判断一个操作数是否大于、小于、等于或者不等于另一个操作数。你可能熟悉大多数这类操作符。但要牢记，在检测两个原始值是否相等时，必须使用“==”，而不是“=”。

==    等于

!=    不等于

>     大于

>=    大于或等于

<     小于

<=    小于或等于

下面的程序ComparisonDemo测试比较操作符：

class ComparisonDemo {

  public static void main(String[] args) {

    int value1 = 1;

    int value2 = 2;

    if(value1 == value2)

                           System.out.println("value1 == value2");

    if(value1 != value2)

                           System.out.println("value1 != value2");

    if(value1 > value2) System.out.println("value1 > value2");

    if(value1 < value2) System.out.println("value1 < value2");

    if(value1 <= value2)

                       System.out.println("value1 <= value2");

  }

}

输出：

 

value1 != value2

value1 < value2

value1 <= value2

2. 条件操作符

“&&”和“||”操作符对两个布尔表达式执行条件与（Conditional-AND）和条件或（Conditional-OR）操作。这两个操作符具有“短路”行为，也就是说只在必要时才计算第二个操作数。

&&   条件与

||   条件或

下面的程序ConditionalDemo1测试这两个操作符：

class ConditionalDemo1 {

  public static void main(String[] args){

    int value1 = 1;

    int value2 = 2;

    if((value1 == 1) && (value2 == 2))

      System.out.println("value1 is 1 AND value2 is 2");

    if((value1 == 1) || (value2 == 1))

      System.out.println("value1 is 1 OR value2 is 1");

  }

}

另一个条件操作符是?:，可以把它看作if-then-else语句（在3.4节中讨论）的简写方式。这个操作符被称为三元操作符（ternary operator），因为它使用三个操作数。在下面的示例中，应该把这个操作符读作：“如果someCondition为true，就把value1的值赋给result。否则，把value2的值赋给result”。

下面的程序ConditionalDemo2测试?:操作符：

class ConditionalDemo2 {

  public static void main(String[] args){

    int value1 = 1;

    int value2 = 2;

    int result;

    boolean someCondition = true;

    result = someCondition ? value1 : value2;

    System.out.println(result);

  }

}

因为someCondition为true，所以程序把“1”输出到屏幕。如果能使代码的可读性更强，就使用?:操作符，而不使用if-then-else语句；例如，当表达式紧凑并且没有副作用（比如赋值）时。

3. 类型比较操作符instanceof

instanceof操作符把对象和指定的类型进行比较。你可以使用它测试某个对象是否是一个类的实例、子类的实例或者实现特定接口的类的实例。

下面的程序InstanceofDemo定义了父类（名为Parent）、简单接口（名为MyInterface）和子类（名为Child），子类Child继承父类并且实现接口。

 

class InstanceofDemo {

  public static void main(String args[]) {

    Parent obj1 = new Parent();

    Parent obj2 = new Child();

    System.out.println("obj1 instanceof Parent: " +

                              (obj1 instanceof Parent));

    System.out.println("obj1 instanceof Child: " +

                             (obj1 instanceof Child));

    System.out.println("obj1 instanceof MyInterface: " +

                             (obj1 instanceof MyInterface));

    System.out.println("obj2 instanceof Parent: " +

                             (obj2 instanceof Parent));

    System.out.println("obj2 instanceof Child: " +

                             (obj2 instanceof Child));

    System.out.println("obj2 instanceof MyInterface: " +

                             (obj2 instanceof MyInterface));

  }

}

class Parent{}

class Child extends Parent implements MyInterface{}

interface MyInterface{}

这个程序的输出为：

obj1 instanceof Parent: true

obj1 instanceof Child: false

obj1 instanceof MyInterface: false

obj2 instanceof Parent: true

obj2 instanceof Child: true

obj2 instanceof MyInterface: true

使用instanceof操作符时，要牢记null不是任何对象的实例。

3.2.3  位操作符和移位操作符

Java编程语言还针对整数类型提供了位操作符和移位操作符。这一节中讨论的操作符不怎么常见。因此这里只简要地介绍它们，目的是让你知道有这些操作符。

一元位求补操作符“~”反转位模式；它可以应用于任何整数类型，把每个“0”转换成“1”，把每个“1”转换成“0”。例如，一个byte包含8位，使用这个操作符处理位模式为“00000000”的值时，将把它的位模式转换为“11111111”。

带符号左移位操作符“<<”把位模式向左移位，带符号右移位操作符“>>”把位模式向右移位。位模式由左侧操作数给定，移位的位置数量由右侧操作数给定。无符号右移位操作符“>>>”把0移位到最左侧的位置，而“>>”操作之后最左侧位置的状态取决于符号扩展。

位&操作符执行位与操作。

位^操作符执行位异或操作。

位|操作符执行位或操作。

对于前面的&，当两个操作数的某位都为1时，结果中的这一位就为1。

对于前面的|，当一个操作数的某位为1时，结果中的这一位就为1。

下面的程序BitDemo使用位与操作符把数字“2”输出到标准输出。

 

class BitDemo {

  public static void main(String[] args) {

    int bitmask = 0x000F;

    int val = 0x2222;

    System.out.println(val & bitmask); // prints "2"

  }

}

3.2.4  操作符小结

下面是Java编程语言支持的操作符的参考小结。

简单赋值操作符

=        简单赋值操作符

算术操作符

+        加法操作符（也用于拼接字符串）

-        减法操作符

*        乘法操作符

/        除法操作符

%        取模操作符

一元操作符

+        一元正操作符；指示正值（但不带这个操作符的数也是正的）

-        一元负操作符；对表达式求反

++      递增操作符；使值增加1

--      递减操作符；使值减去1

!        逻辑求补操作符；反转布尔值

相等和关系操作符

==      等于

!=      不等于

>        大于

>=      大于或等于

<        小于

<=      小于或等于

条件操作符

&&      条件与

||     条件或

?:     三元（if-then-else语句的简写方式）

类型比较操作符instanceof

instanceof把对象和指定的类型进行比较

位和位移位操作符

~      一元位求补

<<     带符号左移位

>>     带符号右移位

>>>   无符号右移位

&      位与

^      位异或

|     位或

问题和练习：操作符

问题

1.   查看下面的代码段。

arrayOfInts[j] > arrayOfInts[j+1]

代码中包含哪些操作符？

2.   查看下面的代码段。

int i = 10;

int n = i++%5;

a. 执行代码后，i和n的值是什么？

b. 不使用后缀递增操作符（i++），而是使用前缀版本（++i），这时i和n的最终值是什么？

3.   为了反转布尔值，应该使用哪个操作符？

4.   比较两个值时应该使用哪个操作符？“=”还是“==”？

5.   解释下面的代码示例：

result = someCondition ? value1 : value2;

练习

1.   把下面的程序改为使用复合赋值：

class ArithmeticDemo {

  public static void main (String[] args){

    int result = 1 + 2; // result is now 3

    System.out.println(result);

    result = result - 1; // result is now 2

    System.out.println(result);

    result = result * 2; // result is now 4

    System.out.println(result);

    result = result / 2; // result is now 2

    System.out.println(result);

    result = result + 8; // result is now 10

    result = result % 7; // result is now 3

    System.out.println(result);

  }

}

2.   在下面的程序中，解释为什么“6”这个值在输出中出现了两次：

class PrePostDemo {

  public static void main(String[] args){

    int i = 3;

    i++;

    System.out.println(i);     // "4"

    ++i;

    System.out.println(i);     // "5"

    System.out.println(++i);  // "6"

    System.out.println(i++); // "6"

    System.out.println(i);     // "7"

  }

}

答案

可以在以下位置找到“问题”和“练习”的答案：

       

tutorial/java/nutsandbolts/QandE/questions_expressions.html