Java运算符

Java 运算符

运算符是一些特殊的符号，它们对一个，两个或多个操作数执行特定的运算，然后返回一个结果。这里的操作数指的就是运算符操作的实体。

Java提供了一组丰富的运算符来操作变量。 我们可以将所有Java运算符分为以下几类：

  • 算术运算符
  • 关系运算符
  • 位运算符
  • 逻辑运算符
  • 赋值运算符
  • 其他运算符

算术运算符

概述

Java 语言提供了执行加减乘除四则运算的运算符。 算数运算符被用在数学表达式中，可以使用任意嵌套的小括号，其作用与数学中相同。下表列出了算术运算符：

（在例子中，初始化两个整型变量a、b：int a = 2; int b = 4;）

实例

以下是算数运算符的实例程序。

加法运算符使用实例：

1
2
3
4
5
6
7
8
9
public class ArithmeticOperators1 {
    public static void main(String[] args) {
        // 声明两个整型变量 num1,num2 分别赋值为 2, 3
        int num1 = 2, num2 = 3;
        // 使用加法运算符，对num1和num2执行相加操作，并将返回结果赋值给result
        int result = num1 + num2;
        System.out.println( num1 + " + " + num2 + " = " + result);
    }
}

运行结果：
1
2 + 3 = 5

减法运算符使用实例：
1
2
3
4
5
6
7
8
9
10
11
12
public class ArithmeticOperators2 {
    public static void main(String[] args) {
        // 声明两个整型变量 num1, num2 分别赋值为 5, 3
        int num1 = 5, num2 = 3;
        // 使用减法运算符，让 num1 加上 num2，并将返回结果赋值给result
        int result = num1 + num2;
        System.out.println( num1 + " + " + num2 + " = " + result);
        // 计算 num2 - num1 的结果
        int result1 = num2 - num1;
        System.out.println( num2 + " - " + num1 + " = " + result1);
    }
}

运行结果：
1
2
5 + 3 = 8
3 - 5 = -2

乘法运算符使用实例：
1
2
3
4
5
6
7
8
9
public class ArithmeticOperators3 {
    public static void main(String[] args) {
        // 声明两个整型变量 num1, num2 分别赋值为 2, 5
        int num1 = 2, num2 = 5;
        // 使用乘法运算符，让 num1 与 num2 相乘，并将返回结果赋值给result
        int result = num1 * num2;
        System.out.println( num1 + " * " + num2 + " = " + result);
    }
}

运行结果：
1
2 x 5 = 10

除法运算符使用实例：
1
2
3
4
5
6
7
8
9
public class ArithmeticOperators4 {
    public static void main(String[] args) {
        // 声明两个整型变量 num1, num2 分别赋值为 10, 2
        int num1 = 10, num2 = 2;
        // 使用除法运算符，让 num1 除以 num2，并将返回结果赋值给result
        int result = num1 / num2;
        System.out.println( num1 + " / " + num2 + " = " + result);
    }
}

运行结果：
1
10 / 2 = 5

取余运算符使用实例：
1
2
3
4
5
6
7
8
9
public class ArithmeticOperators5 {
    public static void main(String[] args) {
        // 声明两个整型变量 num1, num2 分别赋值为 5, 2
        int num1 = 5, num2 = 2;
        // 使用取余运算符，让 num1 对 num2 取余，并将返回结果赋值给result
        int result = num1 % num2;
        System.out.println( num1 + " % " + num2 + " = " + result);
    }
}

编译执行代码，屏幕上将会打印：
1
5 % 2 = 1

自增、自减运算符使用实例：
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ArithmeticOperators6 {
    public static void main(String[] args) {
        // 声明两个整型变量 num1, num2 分别赋值为 5, 2
        int num1 = 5, num2 = 2;
        // 打印 num1 和 num2
        System.out.println("num1=" + num1);
        System.out.println("num2=" + num2);
        num1 ++;
        num2 --;
        System.out.println("num1自增后：" + num1);
        System.out.println("num2自减后：" + num2);
    }
}

运行结果：
1
2
3
4
num1=5
num2=2
num1自增后：6
num2自减后：1

另外，整型之间的除法运算是整除，这也就意味着2 / 4的结果为0，如果我们想像数学一样得到一个小数，可以使用浮点类型的操作数。例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class OperatorDemo1 {
    public static void main(String[] args) {
        // 分组初始化两个整型变量i1、i2，值分别为2、4
        int i1 = 2, i2 = 4;
        // 使i1除以i2，并将返回结果赋值给i3
        int i3 = i1 / i2;
        System.out.println("整型2除以整型4的结果为：" + i3);
        // 分组初始化两个浮点型变量f1、f2，值分别为2、4
        float f1 = 2f, f2 = 4f;
        // 使f1除以f2，并将返回结果赋值给f3
        float f3 = f1 / f2;
        System.out.println("浮点型2除以浮点型4的结果为：" + f3);
    }
}

运行结果：
1
2
整型2除以整型4的结果为：0
浮点型2除以浮点型4的结果为：0.5

要特别注意，在 Java 语言中，算数运算符不能作用于不同类型的操作数。我们来看一个反例：
1
2
3
4
5
6
7
8
9
10
public class OperatorDemo1 {
    public static void main(String[] args) {
        // 初始化布尔类型的变量b，值为true
        boolean b = true;
        // 初始化整型变量i，值为20
        int i = 20;
        // 使用加法运算符，让i与b相加
        int result = i + b;
    }
}

编译代码，将会报错：
1
2
3
4
5
6
7
javac OperatorDemo1.java
OperatorDemo1.java:7: 错误: 二元运算符 '+' 的操作数类型错误
        int result = i + b;
                       ^
  第一个类型:  int
  第二个类型: boolean
1 个错误

编译器给出明确提示：加法运算符的操作数类型错误。这是因为 Java 是强类型的语言，不同类型的操作数的算数运算是违规的，这个原理同样适用于其他算数运算符，此处不再一一列举。

还有一点，自增自减运算符是有前后之分的，++i表示先加1再引用i，i++表示先引用i再加1。将在下一小节举例介绍。

关系运算符

概述

关系运算符又称为比较运算符，比较的结果是一个布尔类型的值（true或false）。

Java 语言有几个可用于比较变量的运算符，如下表所示：

（在例子中，初始化两个整型变量a、b：int a = 2; int b = 4;）

实例

下面是一个比较运算符的实例程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class OperateDemo2 {
    public static void main(String[] args) {
        // 初始化一个双精度浮点型变量d1，值为10
        double d1 = 10;
        // 初始化一个整型变量i1，值也为10
        int i1 = 10;
        System.out.println("id == i1的结果为：" + (d1 == i1));
        System.out.println("id != i1的结果为：" + (d1 != i1));
        System.out.println("id > i1的结果为：" + (d1 > i1));
        System.out.println("id < i1的结果为：" + (d1 < i1));
        System.out.println("id >= i1的结果为：" + (d1 >= i1));
        System.out.println("id <= i1的结果为：" + (d1 <= i1));
    }
}

运行结果：
1
2
3
4
5
6
id == i1的结果为：true
id != i1的结果为：false
id > i1的结果为：false
id < i1的结果为：false
id >= i1的结果为：true
id <= i1的结果为：true

Tips：>、<、>=、<= 这几个运算符左右两边的操作数必须是byte，short，int，long，double，float，char这几种数据类型；而==和!=运算符的操作数既可以是基本数据类型，又可以是引用数据类型。

位运算符

Java 语言还提供了对整数类型执行按位和移位操作的运算符，称作位运算符。
它在实际的编码中并不常用，这部分内容了解即可。
假设a = 60，b = 13;它们的二进制格式表示将如下：

1
2
3
4
5
6
7
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~a = 1100 0011

下表列出了位运算符的基本运算，假设整数变量 a 的值为 60 和变量 b 的值为 13：

逻辑运算符

概述

逻辑运算符可以在表达式中生成组合条件，例如在执行特定语句块之前必须满足的两个或多个条件。使用逻辑运算符，可以描述这些组合条件。逻辑运算的返回结果只能为真或假。

Java 语言中的逻辑运算符，如下表所示：

（在例子中，初始化两个整型变量a、b：int a = 0; int b = 1;）

短路运算

&&和||运算符存在短路行为。短路的意思是：只有在需要的时候才会判断第二个操作数的真假。例如：

1
2
3
4
5
6
7
8
9
10
11
class LogicOperators {
    public static void main(String[] args){
        int a = 1, b = 2;
        if((a == 2) && (b == 2)) {
            System.out.println("a和b都等于2");
        }
        if((a == 1) || (b == 1)) {
            System.out.println("a等于1或b等于1");
        }
    }
}

运行结果：
1
a等于1或b等于1

程序解析：有两个整型变量a和b，值分别为1和2。第一个if语句的条件为逻辑与运算，其第一个操作数a == 2为假，所以无论第二个操作数是真是假，都不去判断，条件直接被判定为假；第二个if语句的条件为逻辑或运算， 其第一个操作数a == 1为真，所以无论第二个操作数是真是假，都不会去判断，条件直接被判定为真。这就是所谓的短路。

赋值运算符

概述

赋值运算符是为指定变量分配值的符号。下标列出了常用 Java 中常用的赋值运算符：

实例

我们来看一个赋值运算符的实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class OperateDemo5 {
    public static void main(String[] args) {
        // 分组初始化三个变量 num1、num2、result，值分别为 20、10、0
        int num1 = 20, num2 = 10,  result = 0;
        System.out.println("初始值：");
        System.out.print("num1=" + num1 + '\t');
        System.out.print("num2=" + num2 + '\t');
        System.out.print("result=" + result + "\t\n");
        System.out.println("开始赋值运算：");
        result += num1;
        System.out.println("result += num1 结果为：" + result);
        result -= num2;
        System.out.println("result -= num2 结果为：" + result);
        result *= num1;
        System.out.println("result *= num1 结果为：" + result);
        result /= num2;
        System.out.println("result /= num2 结果为：" + result);
        result %= 15;
        System.out.println("result %= 15 结果为：" + result);
    }
}

运行结果：
1
2
3
4
5
6
7
8
初始值：
num1=20	num2=10	result=0	
开始赋值运算：
result += num1 结果为：20
result -= num2 结果为：10
result *= num1 结果为：200
result /= num2 结果为：20
result %= 15 结果为：5

其他运算符

条件运算符（? :）

条件运算符也称为三元运算符。我们会在条件语句小节中再次对其介绍。

该运算符由三个操作数组成，用于判断布尔表达式。它的目的是确定应将哪个值分配给变量。条件运算符的语法为：

1
2
3
4
5
6
public class ConditionalOperators {
    public static void main(String[] args) {
        int age = 15;
        System.out.println(age >= 18 ? "在中国你已经成年" :  "在中国你还未成年"); 
    }
}

由于age变量值为15，小于18，age >= 18返回结果为假，因此编译执行后，屏幕将打印：
1
在中国你还未成年

instanceof 运算符

Tips：了解 instanceof 运算符需要一些面向对象的前置知识。目前你可以选择性学习。

instanceof运算符将对象与指定类型进行比较，检查对象是否是一个特定类型（类类型或接口类型）。

instanceof 运算符的语法为：

1
( Object reference variable ) instanceof  (class/interface type)

如果instanceof左侧的变量所指向的对象，是instanceof右侧类或接口的一个对象，结果为真，否则结果为假。
1
2
3
4
5
6
7
public class InstanceOfOperators1 {
    public static void main(String[] args) {
        String name = "imooc";
        boolean b = name instanceof String; 
     	  System.out.println("结果为：" + b);
    }
}

由于字符串变量name是String类型，所以执行代码，屏幕会打印：
1
结果为：true

注意，instanceof运算符不能用于操作基本数据类型，如果将字符串类型name变量改为一个char类型的变量，编译代码将会报错:
1
2
3
4
5
6
InstanceOfOperators1.java:4: 错误: 意外的类型
        boolean b = name instanceof String;
                    ^
  需要: 引用
  找到:    char
1 个错误

运算符的优先级

当多种运算符在一同使用的时候，会有一个执行先后顺序的问题。

下表中的运算符按优先顺序排序。运算符越靠近表格顶部，其优先级越高。具有较高优先级的运算符将在具有相对较低优先级的运算符之前计算。同一行上的运算符具有相同的优先级。
|—-|—-|
|类别 |操作符 |关联性|
后缀 |() [] . (点操作符)| 左到右
一元 |+ + - ！〜 |从右到左
乘性 | /％ |左到右
加性 |+ - |左到右
移位 |>> >>> << |左到右
关系 |>> = << = |左到右
相等 |== != |左到右
按位与 |＆ |左到右
按位异或 |^ 左到右
按位或 ||| 左到右
逻辑与 |&& |左到右
逻辑或 || || 左到右
条件 |？： |从右到左
赋值 |= + = - = = / =％= >> = << =＆= ^ = | = |从右到左
逗号| ， |左到右
当相同优先级的运算符出现在同一表达式中时，如何控制它们计算的先后呢。我们来看一个实例：

1
2
3
4
5
6
7
8
9
public class OperateorsPriority {
    public static void main(String[] args) {
      	int a = 2;
      	int b = 4;
      	int c = 6;
      	int result = a + b - c + a;
     	System.out.println("result = " + result);
    }
}

在计算result的语句的右侧，+ 、-两个运算符优先级相同，如果我们不加以控制，将按照从左到右顺序计算，打印结果为result = 2；但是如果我们想先计算a + b和c + a的值，再计算两者之差，我们可以使用括号()将其顺序进行控制：(a + b) - (c + a)，再执行代码将打印我们想要的结果：result = -2。