Java中的运算符分为以下几种算术运算符：用于执行基本数学计算，例如加法(+)、减法(-)、乘法(*)、除法(/)和取模(%)。这些运算符的操作方式与数学中的操作类似。在进行除法和取模运算时，需要注意除数不能为0，否则会抛出异常。关系运算符：用于比较两个值之间的关系，包括等于(==)、不等于(!=)、大于(>)、小于(<)、大于等于(>=)和小于等于(<=)。这些运算符返回一个布尔值，即true或false。逻辑运算符：用于连接多个布尔表达式，包括逻辑与(&&)、逻辑或(||)和逻辑非(!)。逻辑与和逻辑或运算符可以用于组合多个条件，而逻辑非用于反转布尔值。位运算符：在二进制级别上操作数值，包括按位与(&)、按位或(|)、按位异或(^)、按位取反(~)、左移(<<)和右移(>>)。位运算符在进行底层编程或优化时非常有用。例如，右移运算符可以将数字除以2的n次方。赋值运算符：用于给变量赋值，包括基本的赋值运算符(=)和复合赋值运算符(+=, -=, *=, /=等)。复合赋值运算符将运算和赋值结合在一起，使代码更加简洁。其他运算符：包括条件运算符(?:)、类型比较运算符(instanceof)和类型转换运算符等。

算术运算符

算术运算符包含：加法(+)、减法(-)、乘法(*)、除法(/)和取模(%)；

加法（+）

对于生活中我们最常见的算法就是1+2等于多少？我们是很快速得计算出结果，当时如果使用java编写的话，要怎么编写这个1+2的结果，接下来我们使用个示例来说明。

public class OperatorDemo {    public static void main(String[] args) {        //声明1       int one=1;       //声明2       int two =2;       //1+2的结果值       int three = one+two;       //1+2 输出结果是3       System.out.println(three);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1       int one=1;       //声明2       int two =2;       //2-1的结果值       int result = two+one;       //2-1 输出结果是1       System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1       int one=1;       //声明2       int two =2;       //2 * 1的结果值       int result = two * one;       //2 * 1 输出结果是2       System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1       int one=1;       //声明2       int two =2;       //2 / 1的结果值       int result = two / one;       //2 / 1 输出结果是2       System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //2 % 1的结果值        int result = number % 100;        //10 取模 100 输出结果是10        System.out.println(result);    }}

关系运算符执行后返回一个布尔值，即true或false。

等于(==)

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //声明另外一个数字        int otherNumber = 10;        //10 == 10的结果值        boolean result = number == otherNumber;        //输出结果是true        System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //声明另外一个数字        int otherNumber = 10;        //10 不等于 10的结果值是false        boolean result = number != otherNumber;        //输出结果是false        System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //声明另外一个数字        int otherNumber = 10;        //10 大于 10的结果值是false        boolean result = number > otherNumber;        //输出结果是false        System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //声明另外一个数字        int otherNumber = 10;        //10 小于 10的结果值是false        boolean result = number < otherNumber;        //输出结果是false        System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //声明另外一个数字        int otherNumber = 10;        //10 大于等于 10的结果值是true        boolean result = number >= otherNumber;        //输出结果是true        System.out.println(result);    }}

public class OperatorDemo {    public static void main(String[] args) {        //声明1        int number = 10;        //声明另外一个数字        int otherNumber = 10;        //10 小于等于 10的结果值是true        boolean result = number <= otherNumber;        //输出结果是true        System.out.println(result);    }}

逻辑运算符

用于连接多个布尔表达式，包括逻辑与(&&)、逻辑或(||)和逻辑非(!)。逻辑与和逻辑或运算符可以用于组合多个条件，而逻辑非用于反转布尔值。

逻辑与(&&)

Java中的逻辑与运算符是&&，它用于将两个布尔值进行逻辑与运算。逻辑与运算符是一种二元运算符，这意味着它需要两个操作数来完成运算。在Java中，逻辑与运算符将两个布尔值进行比较，如果两个操作数都为true，则结果为true；否则，结果为false。

public class LogicalAndExample {    public static void main(String[] args) {        boolean a = true;        boolean b = false;        boolean result = a && b; // 逻辑与运算符        System.out.println("Result: " + result); // 输出结果为false    }}

Java中的逻辑或运算符是两个竖线||。当两个操作数中至少有一个为true时，逻辑或的结果就为true。如果两个操作数都是false，那么结果就是false。

public class LogicalOrExample {    public static void main(String[] args) {        boolean a = true;        boolean b = false;        // 使用逻辑或运算符        boolean result = a || b;        System.out.println("Result: " + result); // 输出结果为true    }}

逻辑非运算符是一种单目运算符，这意味着它只需要一个操作数来完成运算。在Java中，逻辑非运算符会将其操作数的布尔值取反。如果操作数为true，则逻辑非的结果为false；反之，如果操作数为false，则结果为true。

public class LogicalNotExample {    public static void main(String[] args) {        boolean a = true;        boolean b = false;        // 使用逻辑非运算符        boolean result1 = !a; // 结果为false        boolean result2 = !b; // 结果为true        System.out.println("Result 1: " + result1);        System.out.println("Result 2: " + result2);    }}

位运算符

在二进制级别上操作数值，包括按位与(&)、按位或(|)、按位异或(^)、按位取反(~)、左移(<<)和右移(>>)。位运算符在进行底层编程或优化时非常有用。例如，右移运算符可以将数字除以2的n次方。

按位与(&)

Java中的按位与运算符是"&"，用于执行二进制位的“与”操作。按位与运算符（&）是一种二元运算符，它对两个数的每一位进行逻辑与操作。按位与的运算规则是：只有当两个相应的二进制位都为1时，结果位才为1；如果任一位为0，则结果位为0。例如，对于数字3和5，它们的二进制表示分别是0000 0011和0000 0101，按位与的结果是0000 0001，即十进制的1。

public class BitwiseAndExample {    public static void main(String[] args) {        int a = 5; // 二进制表示为0000 0101        int b = 3; // 二进制表示为0000 0011        // 使用按位与运算符进行逻辑与操作        int result = a & b; // 结果为0000 0001，即十进制的1        System.out.println("Result: " + result);    }}

Java中的按位或运算符是"|"，用于执行二进制位的“或”操作。按位或运算符（|）是一种二元运算符，它对两个数的每一位进行逻辑或操作。按位或的运算规则是：只要两个相应的二进制位中有一个为1，结果位就为1；如果两个位都是0，则结果位为0。例如，对于数字5和3，它们的二进制表示分别是0000 0101和0000 0011，按位或的结果是0000 0111，即十进制的7。

public class BitwiseOrExample {    public static void main(String[] args) {        int a = 5; // 二进制表示为0000 0101        int b = 3; // 二进制表示为0000 0011        // 使用按位或运算符进行逻辑或操作        int result = a | b; // 结果为0000 0111，即十进制的7        System.out.println("Result: " + result);    }}

按位异或(^)

Java中的按位异或运算符是"^"，用于执行二进制位的“异或”操作。按位异或运算符（^）是一种二元运算符，它对两个数的每一位进行异或操作。异或的运算规则是：如果两个相应的二进制位相同，则结果为0；如果两个相应的二进制位不同，则结果为1。例如，对于数字5和3，它们的二进制表示分别是0000 0101和0000 0011，按位异或的结果是0000 0110，即十进制的6。

public class BitwiseXorExample {    public static void main(String[] args) {        int a = 5; // 二进制表示为0000 0101        int b = 3; // 二进制表示为0000 0011        // 使用按位异或运算符进行逻辑异或操作        int result = a ^ b; // 结果为0000 0110，即十进制的6        System.out.println("Result: " + result);    }}

左移(<<)

Java中的左移运算符是"<<"，用于将一个数的二进制位向左移动指定的位数。左移运算符（<<）是一种二元运算符，它对一个数进行左移操作。左移的运算规则是：将原数的二进制位向左移动指定的位数，右边空出的位用0填充。例如，对于数字5和3，它们的二进制表示分别是0000 0101和0000 0011，将它们分别左移2位后得到的结果分别为0001 0100和0000 0011，即十进制的20和3。

public class Main {    public static void main(String[] args) {        int number = 5; // 二进制表示为0000 0101        int shift = 2;        int result = number << shift; // 结果为0001 0100，即十进制的20        System.out.println("Result: " + result);    }}

在这个例子中，我们定义了一个整数变量number，它的值为5。然后，我们使用左移运算符（<<）将number向左移动了2位，并将结果存储在变量result中。最后，我们将结果打印出来。

右移(>>)

Java中的右移运算符（>>）用于将二进制数向右移动指定的位数。右移操作相当于将二进制数除以2的指定次方，同时在左侧补0。

public class RightShiftExample {    public static void main(String[] args) {        int num = 8; // 二进制表示为 0000 1000        int result = num >> 1; // 右移一位，结果为 0000 0100，即十进制的4        System.out.println("右移后的结果为： " + result);    }}

赋值运算符

用于给变量赋值，包括基本的赋值运算符(=)和复合赋值运算符(+=, -=, *=, /=等)。复合赋值运算符将运算和赋值结合在一起，使代码更加简洁。

赋值运算符（=）

Java中的赋值运算符（=）用于将一个值赋给变量

public class AssignmentOperatorExample {    public static void main(String[] args) {        int a = 5; // 将整数5赋值给变量a        double b = 3.14; // 将浮点数3.14赋值给变量b        char c = 'A'; // 将字符'A'赋值给变量c        boolean d = true; // 将布尔值true赋值给变量d        String str = "Hello, World!"; // 将字符串"Hello, World!"赋值给变量str        System.out.println("a = " + a);        System.out.println("b = " + b);        System.out.println("c = " + c);        System.out.println("d = " + d);        System.out.println("str = " + str);    }}

在这个例子中，我们使用赋值运算符将不同类型的值分别赋给了变量a、b、c、d和str。然后，我们使用System.out.println()方法输出这些变量的值。

复合赋值运算符（+=）

Java中的+=运算符是一个复合赋值运算符，用于将右侧的值加到左侧的变量上，并将结果赋给左侧的变量

public class CompoundAssignmentOperatorExample {    public static void main(String[] args) {        int a = 5;        a += 3; // 等同于 a = a + 3;        System.out.println(a); // 输出8        double b = 2.5;        b += 1.5; // 等同于 b = b + 1.5;        System.out.println(b); // 输出4.0        String str = "Hello";        str += ", World!"; // 等同于 str = str + ", World!";        System.out.println(str); // 输出"Hello, World!"    }}

在这个例子中，我们使用+=运算符将不同的值添加到变量a、b和str上，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

复合赋值运算符（-=）

Java中的"-="运算符是一个复合赋值运算符，用于将右侧的值减去左侧的变量，并将结果赋给左侧的变量。

public class CompoundAssignmentOperatorExample {    public static void main(String[] args) {        int a = 5;        a -= 3; // 等同于 a = a - 3;        System.out.println(a); // 输出2        double b = 2.5;        b -= 1.5; // 等同于 b = b - 1.5;        System.out.println(b); // 输出1.0        String str = "Hello";        str -= ", World!"; // 等同于 str = str - ", World!";        System.out.println(str); // 输出"Hello"    }}

在这个例子中，我们使用"-="运算符将不同的值从变量a、b和str中减去，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

复合赋值运算符（*=）

Java中的"*="运算符是一个复合赋值运算符，用于将右侧的值乘以左侧的变量，并将结果赋给左侧的变量。

public class CompoundAssignmentOperatorExample {    public static void main(String[] args) {        int a = 5;        a *= 3; // 等同于 a = a * 3;        System.out.println(a); // 输出15        double b = 2.5;        b *= 1.5; // 等同于 b = b * 1.5;        System.out.println(b); // 输出3.75        String str = "Hello";        str *= 2; // 等同于 str = str + str;        System.out.println(str); // 输出"HelloHello"    }}

在这个例子中，我们使用"*="运算符将不同的值乘以变量a、b和str，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

复合赋值运算符（/=）

Java中的"/="运算符是一个复合赋值运算符，用于将左侧变量除以右侧的值，并将结果赋给左侧的变量。

public class CompoundAssignmentOperatorExample {    public static void main(String[] args) {        int a = 10;        a /= 2; // 等同于 a = a / 2;        System.out.println(a); // 输出5        double b = 4.0;        b /= 2.0; // 等同于 b = b / 2.0;        System.out.println(b); // 输出2.0        String str = "Hello";        str /= " World"; // 等同于 str = str + " World";        System.out.println(str); // 输出"Hello World"    }}

在这个例子中，我们使用"/="运算符将不同的值除以变量a、b和str，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

其他运算符

包括条件运算符(?:)、类型比较运算符(instanceof)和类型转换运算符等。

条件运算符(?:)

Java中的条件运算符（也称为三元运算符）是一种简洁的表示条件语句的方法。它的语法如下：

条件表达式 ? 表达式1 : 表达式2;

public class ConditionalOperatorExample {    public static void main(String[] args) {        int a = 10;        int b = 20;        int max = (a > b) ? a : b;        System.out.println("The maximum value is: " + max);    }}

在这个例子中，我们使用条件运算符来比较变量a和b的值，并将较大的值赋给变量max。如果a大于b，则整个条件运算符的值为a；否则，整个条件运算符的值为b。

类型比较运算符(instanceof)

Java中的类型比较运算符（instanceof）用于检查一个对象是否属于某个类或接口的实例。

public class Main {    public static void main(String[] args) {        String str = "Hello, world!";        boolean isString = str instanceof String;        System.out.println("str 是 String 类型的实例吗？ " + isString); // 输出：str 是 String 类型的实例吗？ true        Integer num = 42;        boolean isInteger = num instanceof Integer;        System.out.println("num 是 Integer 类型的实例吗？ " + isInteger); // 输出：num 是 Integer 类型的实例吗？ true        double dbl = 3.14;        boolean isDouble = dbl instanceof Double;        System.out.println("dbl 是 Double 类型的实例吗？ " + isDouble); // 输出：dbl 是 Double 类型的实例吗？ false    }}

类型转换运算符自动类型转换（Implicit Type Conversion）

int a = 10;double b = a; // 自动类型转换

编译器会自动将较小的数据类型转换为较大的数据类型。例如，将 int 类型的变量转换为 double 类型时，int 类型的值会被转换为 double 类型的值。

显式类型转换

需要使用类型转换运算符将一个数据类型转换为另一个数据类型。例如，将 double 类型的变量转换为 int 类型时，可以使用强制类型转换运算符（如 (int)）

double a = 10.5;int b = (int) a; // 显式类型转换

包装类型转换

Java 提供了一些包装类，如 Integer、Double 等，它们分别对应基本数据类型 int、double。通过包装类型转换，可以将基本数据类型转换为对应的包装类对象，或者将包装类对象转换为对应的基本数据类型。

int a = 10;Integer b = a; // 包装类型转换double c = 10.5;Double d = c; // 包装类型转换

使用 Integer.parseInt()、Double.parseDouble() 等方法将字符串转换为数字。

String str1 = "10";int num1 = Integer.parseInt(str1); // 字符串到数字的转换String str2 = "10.5";double num2 = Double.parseDouble(str2); // 字符串到数字的转换

结语

本章节学习了Java中的运算符，

1、算术运算符：用于执行基本的数学运算，如加、减、乘、除等；关系运算符：用于比较两个值之间的关系，如等于、不等于、大于、小于等。布尔逻辑运算符：用于连接多个布尔表达式，如与、或、非等。位运算符：用于对整数进行二进制位操作。条件运算符：也称为三元运算符，用于根据一个布尔表达式的值来选择两个值中的一个。赋值运算符：用于将一个值赋给变量。算术运算符：用于执行基本的数学运算，如加、减、乘、除等。类型比较运算符：用于检查一个对象是否属于某个类或接口的实例。