【java基础】- 你真的了解运算符吗？

一 前言

学习java运算符的基础是你对数学和计算机原理有一定的要求，如果文章中有些位运算不懂是生么意思，我建议大家去学习一下计算机原理，计算机组成类别的书籍，你也不用深入过多，只要了解计算机大概结构，变量存储，相关的位运算，反码之类；如果你懒得学习也行，java还是能继续学习下去，也就是散失了部分计算能力,当然作者会尽量用示例让缺乏计算机原理的读者读懂位运算，下文也是详细介绍了，这篇对于基础不好的读者一定要看到尾，我对于0基础的读者要求是将作者的文章读懂，跟着敲一遍，然后网上或者书籍中找对应的题目练手；

关于java8新特性中的运算符也不会在此篇出现，进阶学习者可以查阅作者相关文章，初学者按此文学习，想了解更多基础文章请看作者基础系列专栏；

二 算数运算符

2.1 一元运算符

一元运算符是指只对一个表达式执行操作，该表达式可以是数值数据类型类别中的任何一种数据类型；表达式式什么，表达式可以是一个变量（例如a），也可以是变量和数学符号的组合(例如a+b)；

一元运算符

1. - 标识 取反，负数取反是正数，正数取反是负数；
2. – 自减，自减的意思就是变量对自身减1
3. ++ 自增，自增的意思就是变量对自身加1

示例：

public class Arithmetic {

    public static void main(String[] args) {

        int zszxz1 = 100;
        // 取负
        int a = -zszxz1;
        // 自减先赋值后运算
        int b = zszxz1--;
        // 自减先运算后赋值
        int c = --zszxz1;
        // 自增先赋值后运算
        int d = zszxz1++;
        // 自增运算后赋值
        int e = ++zszxz1;
        System.out.println("取负:"+a);//-100
        System.out.println("自减先赋值后运算:"+b);//100 先将 zszxz1赋值给b，zszxz1再减1
        System.out.println("自减先运算后赋值:"+c);//98 （注意此时zszxz1值是99）先将 zszxz1 减1 再复制给c
        System.out.println("自增先赋值后运算:"+d);//98 （注意此时zszxz1值是98）先将 zszxz1 赋值给 d 再将 zszxz1加1
        System.out.println("自增运算后赋值:"+e);//100 （注意此时zszxz1值是99） 先将 zszxz1 加1 再赋值给 e

    }
}

2.2 二元运算符

二元运算是由两个元素形成第三个元素的一种规则；其意思很简单，也就是说左右使用两个表达式，中间用运算符连接起来就的到了结果；

1. + 意指两个表达式相加；
2. - 意指两个表达式相减；
3. * 意指两个表达式相乘；
4. / 意指两个表达式取商；
5. % 意指两个表达式取余；

示例：

    public static void main(String[] args) {

        int zszxz2 = 10;
        int zszxz3 = 3;
        int a = zszxz2 + zszxz3;
        int b = zszxz2 - zszxz3;
        int c = zszxz2 * zszxz3;
        int d = zszxz2 / zszxz3;
        int e = zszxz2 % zszxz3;

        System.out.println("相加 :"+a);// 13
        System.out.println("相减 :"+b);// 7
        System.out.println("相乘 :"+c);// 30
        System.out.println("求商 :"+d);// 3
        System.out.println("取余 :"+e);// 1
        // 10 除以 3 是 商是 3 余数为1  你可以反过来理解 3 * 3 + 1 = 10 
    }

三 赋值操作

1. = 意指赋值，就是将一个变量的值复制一份给另一个变量的过程；
2. += 意指加并赋值；
3. -= 意指减并赋值；
4. *= 意指乘并赋值；
5. /= 意指取商并赋值；
6. %= 意指取余并赋值；

示例：

    public static void main(String[] args) {
        int zszxz4 = 10;
        int zszxz5 = 3;

        int a = zszxz4;
        System.out.println("赋值："+a);//10
        // 等同于 zszxz5 = zszxz5 - zszxz4
        zszxz5 -= zszxz4;
        System.out.println("减并赋值 :"+zszxz5);//-7
        // 等同于 zszxz5 = zszxz5 + zszxz4
        zszxz5 += zszxz4;
        System.out.println("加并赋值 :"+zszxz5);//3
        // 等同于 zszxz5 = zszxz5 * zszxz4
        zszxz5 *= zszxz4;
        System.out.println(" 乘并赋值:"+zszxz5);//30
        // 等同于 zszxz5 = zszxz5 / zszxz4
        zszxz5 /= zszxz4;
        System.out.println(" 取商并赋值:"+zszxz5);//3
        // 等同于 zszxz5 = zszxz5 % zszxz4
        zszxz5 %= zszxz4;
        System.out.println("取余并赋值 :"+zszxz5);//3
    }

四 位运算符

4.1 位运算说明：

计算机的位运算符很多，计算机在进行运算的时候是使用二进制计算，也就说都是使用0和1表示运算（例如 0000 1000），计算机的正负数主表示形式要有原码、反码和补码（补码=反码+1）的方式计算的来，后文会说明；

什么是位运算呢，位运算是指将二进制使用位运算符进行操作后的结果，详细的位运算符号说明在下列表格中已经列出；下面有张图能够帮读者更好理解什么是位，每个位都是2的次方，经过计算后会得到我们想要的结果；不同的进制位数不同，不同的数据类型位数也不同；

计算机中的位图示例：

扫描二维码关注公众号，回复： 8501376 查看本文章

4.2 位运算符号

关于带有赋值操作的位运算跟平常的位运算符没多大区别，作者不会赘述，如果是初学者，请自行实现；

运算符号	含义	说明
<<	表示带符号左移	低位补0
>>	表示右移	正数高位补0，负数高位补1
>>>	无符号右移	高位补0
~	取反	取得原码的反码
&	位与	两个操作数相与
|	位或	两个操作数相或
^	位异或	两个操作相异或
<<=	左移并赋值	a <<= b <=> a = a<<b
>>=	右移并赋值	a >>=b <=> a = a>>b
>>>=	无符号右移并赋值	a >>>= b <=> a = a>>>b
&=	按位与并赋值	a &=b <=> a = a&b
|=	按位或并赋值	a |=b <=> a = a | b
^=	按位异或并赋值	a ^=b <=> a = a^ b

4.3 位负数

负数是指原值进行取绝对值然后进行取反码，再加1操作；反码的意思是将位数的值取反，在二进制中只有0和1，那么0取反就是1，1取反就是0；注意的是计算机中的最高位表示符号位，0表示正数，1表示负数,在位的左右移动过程中，正数表现形式就是原码（原来的二进制），其运算的结果是不会丢失精度，也相对简单，下文就不会举例说明，而是针对负数的位移动进行详解；

以byte的-6为例子：

1. -6取绝对值二进制6： 0000 0110
2. 6的反码：1111 1001
3. 6的反码加1：1111 1010

在java中byte会默认转int（32位）计算，我们在int的高位默认补1，最终的-6的表示结果如下：
1111 1111 1111 1111 1111 1111 1111 1010

好了啊你在计算的时候就需要将这个过程逆过来计算，你就得出了一个我们能够认识的负数；后面的学习中其实有方法进行操作，真不需你计算，了解一下就好，我是怕你失去学习的自信啧啧；

  public static void main(String[] args) {

        byte zszxz1 = -6;
        // -6
        System.out.println(zszxz1);
    }

4.4 左移

左移相对简单，在位运算的时候，是直接进行位数左移，低位是直接补0，不会出现丢失精度的情况；

    public static void main(String[] args) {

        byte zszxz1 = -6;
        // -24
        System.out.println(zszxz1<<2);
    }

我们需要分析一下(也就是上面提到的逆过程)：

1. -6的二进制： 1111 1111 1111 1111 1111 1111 1111 1010
2. -6左移二位：1111 1111 1111 1111 1111 1111 1110 1000
3. 减一： 1111 1111 1111 1111 1111 1111 1110 0111
4. 取反 0000 0000 0000 0000 0000 0000 0001 1000
5. 计算后加个负号：- ( 2^3 + 2^4) = -(8 + 16) =-24

4.5 右移

位运算中右移是正数，高位是补0，负数是补1，在运行的时候也不会出现丢失精度的情况；

1. -6的二进制： 1111 1111 1111 1111 1111 1111 1111 1010
2. -6右移二位：1111 1111 1111 1111 1111 1111 1111 1110
3. 减一： 1111 1111 1111 1111 1111 1111 1111 1101
4. 取反 0000 0000 0000 0000 0000 0000 0000 0010
5. 计算后加个负号：- ( 2^1 ) = -2

public static void main(String[] args) {

        byte zszxz1 = -6;
        // -2
        System.out.println(zszxz1>>2);
    }

4.6 无符号右移

无符号右移是指不带符号移动，高位补0；无符号右移负数后右可能会造成精度损失；

1. -6的二进制： 1111 1111 1111 1111 1111 1111 1111 1010
2. -6无符号右移二位： 0011 1111 1111 1111 1111 1111 1111 1110
3. 计算：2^1 +2^2+.......+2^29 = 1073741822

 public static void main(String[] args) {

        byte zszxz1 = -6;
        // 1073741822
        System.out.println(zszxz1>>>2);
    }

我们转换成十六进制进行验证一下晕：

 public static void main(String[] args) {

        int z = 0x3ffffffe;
        // 1073741822
        System.out.println(z);
    }

4.7 取反

取反使用符号 ~ ，有了上面的基础很容；

1. -6的二进制： 1111 1111 1111 1111 1111 1111 1111 1010
2. -6取反： 0000 0000 0000 0000 0000 0000 0101
3. 计算： （ 2^1 + 2^2）= 5

public static void main(String[] args) {
        // -5
        System.out.println(~-6);
    }

4.8 位与

位的与运算使用符号 &，意指，只有1和1相与结果是1，其他情况相与结果都为0；

1. 19表示 : 0001 0011
2. 17表示：0001 0001
3. 相与得： 0001 0001

public static void main(String[] args) {
    // 19
    byte zxzxz1 = 0b00010011;
    // 17
    byte zxzxz2 = 0b00010001;
    // 17
    System.out.println(zxzxz2 & zxzxz1);
}

4.9 位或

位的或运算使用符号 | , 仅当0和0或的时候为0，其他情况都是1；

1. 19表示 : 0001 0011
2. 17表示：0001 0001
3. 相或得： 0001 0011

    public static void main(String[] args) {
        // 19
        byte zxzxz1 = 0b00010011;
        // 17
        byte zxzxz2 = 0b00010001;
        // 19
        System.out.println(zxzxz2 | zxzxz1);
    }

4.10 位异或

位异或的符号是 ^ , 当位和对应的位值不同就是1（例如0和1），值相同就是0（例如1和1）；

1. 19表示 : 0001 0011
2. 17表示：0001 0001
3. 异或得： 0000 0010

public static void main(String[] args) {
        // 19
        byte zxzxz1 = 0b00010011;
        // 17
        byte zxzxz2 = 0b00010001;
        // 2
        System.out.println(zxzxz2 ^ zxzxz1);
    }

五 关系运算符

关系运算符是比较2个表达式的关系，java跟c一样，也提供了6种关系运算符。其值只为true，或者false，即布尔类型，在数学上习惯称为真和假；

运算符	含义	示例
>	大于	a > b , 若 a大于b，返回true,否则返回false
<	小于	a < b，若 a小于b，返回true,否则返回false
==	等于	a == b 若 a等于b，返回true,否则返回false
>=	大于等于	a >= b, 若 a大于等于b，返回true,否则返回false
<=	小于等于	a <= b , 若 a小于等于b，返回true,否则返回false
!=	不等于	a !=b , 若 a不等于b，返回true,否则返回false

public static void main(String[] args) {

    int zszxz1 = 1024;
    int zszxz2 = 1327;
    // 判断大于
    boolean a = zszxz1 > zszxz2;
    // 判断小于
    boolean b = zszxz1 < zszxz2;
    // 判断等于
    boolean c = (zszxz1 == zszxz2);
    // 判断大于等于
    boolean d = zszxz1 >= zszxz2;
    // 判断小于等于
    boolean f = zszxz1 <= zszxz2;
    // 判断不等于
    boolean g = zszxz1 != zszxz2;

    // 输出
    System.out.println("1是否大于2："+a);//false
    System.out.println("1是否小于2："+b);//true
    System.out.println("1是否等于2："+c);//false
    System.out.println("1是否大于等于2："+d);//false
    System.out.println("1是否小于等于2："+f);//true
    System.out.println("1是否不等于2："+g);//true

}

六 逻辑运算符

逻辑运算符是指 对两个表达式（他们的结果都是为true或者false）进行运算，其结果也是布尔型；

运算符	含义	说明
！	表示取非	若表达式为true，取非后为false；若表达式为false，取非后为true
|	表示相或	false跟false相或为false，其他情况都为true
&	表示相与	true跟true相与为true，其他情况都为false
||	表示短路或	false跟false相或为false，其他情况都为true
&&	表示短路与	true跟true相与为true，其他情况都为false

短路与和短路或 跟 普通的与和或相比，其速度更快；比如 a || b 若 a为真，那么整个式子就为真，不会再去判断 b，仅当 a为假的时候才会判断b；再比如 a && b ，若 a 为 假，那么整个式子都为假，不会再去判断b，仅当a为真时，才去判断b的真假性；普通的或和与都会进行判断，固推荐使用短路与，短路或提高运算效率；

public static void main(String[] args) {

    boolean zszxz1 = 1 > 2;//false
    boolean zszxz2 = 1 < 2;//true

    // 取非
    boolean a = !zszxz1;
    // 逻辑与
    boolean b = zszxz1 & zszxz2;
    // 逻辑或
    boolean c = zszxz1 | zszxz2;
    // 短路与
    boolean d = zszxz1 && zszxz2;
    // 短路或
    boolean g = zszxz1 || zszxz2;

    System.out.println("false取非 :"+a);//true
    System.out.println("false与true :"+b);//false
    System.out.println("false或tre :"+c);//true
    System.out.println("false短路与true :"+d);//false
    System.out.println("false短路或true :"+g);//true


}

七 三元运算符

三元运算符，是指通过两个运算符号连接三个表达式（ boolean-express ? value1 : value2 ）,可以看见,
boolean-express 表达式最终运算结果是个布尔值，若 这个值为true，那么整个式子的最终结果就是 value1,否则最终结果就是value2；通俗一点将就是： 我问小盆友你今天几岁啦，若小盆友说不知道（ boolean-express 为 false），那我就拿了大棒棒糖在小朋友面前晃啊晃，等小朋友伸手要时我自己吃了（value2），感觉好贱啊；若小盆友回答知道（ boolean-express 为 true），并且给出年龄数字，我就将棒棒糖给小盆友（value1）;也就是根据布尔类型表达式结果给出两种选择结果；这跟后面学习的if - else语句也是相同的结果，初学者留个印象；

public static void main(String[] args) {

        // 3 是否大于是 ，是返回 5否则返回6
        int i = 3 > 4 ? 5 : 6;
        System.out.println(i);// 6
        // 2 左移3位后是否大于7，是返回2.0，否则返回1.0
        double d = (2 << 3) > 7 ? 2.0 : 1.0;
        System.out.println(d);//2.0
        // 0b0001000 或上 0b01010101 是否大于100，是返回 0b10001000 否则返回0b1
        byte b = (0b0001000 | 0b01010101) > 100 ? 0b10001000 : 0b1;
        System.out.println(b);// 1

    }

八 对象类型判断

之前文章提过，每个对象都有一个类型，如何判断对象是属于那个类型就需要用到instanceof关键字，那么初学者这边就留个印象，了解这个关键字的具体作用，在后面文章出到关于类的继承时会用到；关于运算符号的优先级大致是【算数->位->关系->逻辑->赋值】，在使用到优先级时建议使用小括号起来，以免出错；