java的常见运算符详解（包含与C不同的地方）

一、基本四则运算符：加减乘除模

1. 都是二元运算符，使用时必须要有左右两个操作数
2. int / int 结果还是int类型，而且会向下取整

public class helloworld{
    public static void main(String[] args) {
        System.out.println(10%3);
        System.out.println(10%-3);//10除以-3 = -3.......1
        System.out.println(-10%3);//-10除以3 = -3.......-1
        System.out.println(-10%-3);//10除以-3 = 3.......-1
        System.out.println(12.5%3);//12.5除以3 = 4......0.5,java是可以浮点型模整型的，c不可以，但是这个实际也没有意义
        System.out.println(3/2);//这个得到的是1
        System.out.println(3.0/2);//这个得到的是1。5
    }
}

3. 运算符两边操作数不一致时，类型小的向类型大的提升

System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.2

上面代码中3.0/2也是这个道理

二、 增量运算符 += -= *= %=

该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。

public class helloworld{
    public static void main(String[] args) {
        int a = 1;
        a += 2; // 相当于 a = a + 2
        System.out.println(a); // 输出3
        a -= 1; // 相当于 a = a - 1
        System.out.println(a); // 输出2
        a *= 3; // 相当于 a = a * 3
        System.out.println(a); // 输出6
        a /= 3; // 相当于 a = a / 3
        System.out.println(a); // 输出1
        a %= 3; // 相当于 a = a % 3
        System.out.println(a); // 输出2
    }

但是我们注意一点
java还支持这种增量运算

public class helloworld{
    public static void main(String[] args) {
        short sh = 1;
        sh += 2;
        System.out.println(sh); // 输出3
    }
}

我们要理解这里面是自动进行了类型转换的，sh+=2与sh = sh+2在数学上等价，sh在加2是会进行类型提升，扩充为int型，再与整型常量2相加。此时结果是int型的，然后系统在自动强制类型转化为short.所以一定要注意sh还是short型。
此外，sh+=2与sh = sh+2在数学上等一样，但是在java语法中是不一样的，例如在本例中前者不会报错，但是就这就会报错。
这里就需要我们手动的强制类型转换（+= 中系统自动强制类型转换的，所以不报错）

这个例子还不明显下面这个例子就很明显

public class helloworld{
    public static void main(String[] args) {
        short sh = 1;
        byte ch = 127;
        byte th = 127;
        sh += 2;
        ch += 1;
        th += 128;
        System.out.println(sh); // 输出3
        System.out.println(ch); // 输出-128，这就是系统自动强制类型转化后会变成-128
        System.out.println(th); //输出-1
    }
}

3. 自增/自减运算符 ++ –
   ++是给变量的值+1，–是给变量的值-1。

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

注意：
如果单独使用，【前置++】和【后置++】没有任何区别
如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1
只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

三、关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

这个和C一样，几乎没区别，主要注意，
true false都没有等于1,0的说法
当需要多次判断时，不能连着写，比如：3 < a < 5，这个和C一样

四、逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

4.1逻辑与 &&

语法规则：布尔表达式1 && 布尔表达式2，左右表达式必须是boolean类型的结果。
特点：先去执行表达式1，如果表示式1为真，则去执行表达式2，如果表达式2为真，则整体为真，表达式2为假，则整体为假。但是如果表达式2为假，则不会执行表达式2，所以&&又叫短路与。

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

4.2逻辑或 ||

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果
特点：如果表达式1为真就不执行表达式2，这里就已经发生短路了，如果表达式1为假，就就继续执行表达式2，表达式2为真则整体为真。

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

4.3 逻辑非 !

语法规则：! 表达式
真变假，假变真。

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

五、位运算符

Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据。位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.

5.1按位与 &:

如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

int a = 10;
int b = 20;
System.out.println(a & b);//输出为0

5.2.按位或 |

如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

int a = 10;
int b = 20;
System.out.println(a | b);//输出30

注意:
当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算.
但是 & | 就没有短路的性质，两边的表达式也是需要执行的。

5.3按位取反 ~

如果该位为 0 则转为 1, 如果该位为 1 则转为 0

5.4按位异或 ^:

如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.（相异为1，相同为0）
注：
0与任何数字异或都等于数字本身
两个相同的数异或的结果是0

六、移位运算

移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

<< >>都是和C语言一样的
“>>>”是java特有的

左移 <<:
最左侧位不要了, 最右侧补 0.
注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数。
右移 >>:
最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
无符号右移 >>>:
最右侧位不要了, 最左侧补 0.
注意:
左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
移动负数位或者移位位数过大都没有意义.

七、条件运算符

条件运算符只有一个: ？ ：
语法规则：表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

1. 表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换

public class helloworld{
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a > b? 1 : 2.0;
        System.out.println(c);
    }
}

2. 表达式不能单独存在，其产生的结果必须要被使用

int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句

来看一个题目

public class helloworld{
    public static void main(String[] args) {
        System.out.println((true == true) ? (true == true) ? false : true : false);
        System.out.println((true == true) ? ((true == true) ? false : true ): false);//两个表达式完全相同，结果是false
    }
}

八、运算符的优先级

一般而言，单目运算符优先级较高，赋值运算符优先级较低。算术运算符优先级较高，关系和逻辑运算符优先级较低。多数运算符具有左结合性，单目运算符、三目运算符、赋值运算符具有右结合性。

到此。