(JavaSE)运算符

一、算术运算符

算术运算符	意义
+	相加
–	相减
*	乘积
/	商
%	求余数(求模)
++	自加1
--	自减1

public class Test1 {
    public static void main(String[] args) {
        int a = 11;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);
        System.out.println(++a);
        System.out.println(b--);
        System.out.println(b);
        System.out.println(10.2 % 2.0);
    }
}

其结果如下：

1. 值得注意的是在 java 中支持浮点数的求模，而 c 语言则不支持
2. 在进行整数除法时，只进行整数运算
3. ++ 和 - - 有前置和后置之分，我们可以看到 ++a 为前置加加，先 ++，再打印，b-- 为后置减减，先打印再 --，所以先打印2，再 – ，不管如何，只要执行完 ++，或减减语句，其值都会发生改变。如 b–，其执行完后，b 必发生-- 运算。

二、关系运算符

关系运算符	意义
>	大于
>=	大于等于
<	小于
<=	小于等于
==	等于
!=	不等于

public class Test2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        System.out.println(a > b);
        System.out.println(a >= b);
        System.out.println(a < b);
        System.out.println(a <= b);
        System.out.println(a == b);
        System.out.println(a != b);
    }
}

注意：所有关系运算符的运算得到的结果都是布尔类型，为 true 或 false。

以上结果为：

三、逻辑运算符

注意：所有逻辑运算符两边要求都为布尔类型，并且最终结果也为布尔类型，当然 & 与 | 两边跟整数时执行的是位运算，到位运算再讲解。

逻辑运算符	意义
&	逻辑与(并且)
|	逻辑或(或者)
!	逻辑非(取反)
&&	短路与
||	短路或

   1. 逻辑与 &

1. 表达式1 & 表达式2 , 例如：true & true，则为 true，true & false，为 false，false & false ,为 false。
2. 即两边为 true 时才为 true。
3. 逻辑运算符的要求：在逻辑运算符开头。

public class Test3 {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        int c = 5;
        System.out.println(a > b & b > c);
        System.out.println(a < b & a > c);
        System.out.println(a ==b & a <= c);
    }
}

其结果为：

   2. 逻辑或 |

1. 表达式1 | 表达式2.
2. 两边中，只要有一个表达式为 true 就为 true (两边为 false 才为 false)。
3. 逻辑运算符的要求：在逻辑运算符开头。

public class Test3 {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        int c = 5;
        System.out.println(a > b | b > c); //true | true
        System.out.println(a < b | a > c); //false | true
        System.out.println(a == b | a <= c); // false | false 
    }
}

其结果为：

   3. 逻辑非 ！

1. 对一个布尔类型进行取反
2. 逻辑运算符的要求：在逻辑运算符开头。

public class Test3 {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(!true);
        System.out.println(!(a < b));
    }
}

其结果为：

   4. 短路与 &&

1. 表达式1 && 表达式2 ，和逻辑与 & 的判断方式一样，不同的是当表达式1 为 false 时 表达式2 就不执行了。

public class Test3 {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        int c = 5;
        System.out.println(++a < b && (b + 10) > c); //false && true
        System.out.println(a);
        System.out.println(b);
    }
}

我们来看看结果：
从 a 和 b 的结果可以看到，当 表达式1 为false时，表达式2 就不执行了。当表达式1 为true 时，表达式2 才会执行。

   5. 短路或 ||

1. 表达式1 || 表达式2，与逻辑或 | 的判断方法一样，不同的是当表达式1 为true 时，表达式2 就不执行了。

public class Test3 {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        int c = 5;
        System.out.println(++a > b || (b + 10) < c); //true && false
        System.out.println(a);
        System.out.println(b);
    }
}

其结果为：

四、位运算符

   1. 按位与 &

1. 注：两边为整数时才执行位运算
2. 整数1 & 整数2，对二进制进行按位与，当同时为 1 时才为 1 ，否则都为0。

这里我们直接上例题。

public class Test4 {
    public static void main(String[] args) {
        byte a = 6;
        byte b = 3;
        System.out.println(a & b);
    }
}

我们来看看结果：

   2. 按位或 |

1. 整数1 | 整数2，对二进制进行按位或运算，当两个都为 0 时才为 0，有一个为 1 时为 1。

例：

public class Test4 {
    public static void main(String[] args) {
        byte a = 6;
        byte b = 1;
        System.out.println(a | b);
    }
}

   3. 按位取反 ~

1. ~整数，对二进制进行取反，即 0 变为 1，1 变为 0。

例：

public class Test4 {
    public static void main(String[] args) {
        int a = 0x00000005;
        System.out.printf("%x\n", ~a);
    }
}

   4. 按位异或 ^

1. 整数1 ^ 整数2，对两个二进制数进行异或，不同为1， 相同为0。

public class Test4 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 5;
        System.out.println(a ^ b);
    }
}

五、赋值运算符

1. 基本赋值运算符为 =
2. 扩展赋值运算符有：+=、-=、*=、/=、%=，使用扩展赋值运算符的时候，永远都不会改变运算结果类型。如，byte a = 1, a += 1，a自诞生以来是byte类型，那么a变量的类型永远都是byte。不会变。不管后面是多大的数字。
3. byte a = 1 ，a += 1，相当于 a = a +1，但是他们是有所不同的接下来我们来举列子：

这里我们可以看到错误了，因为a + 1为 int 类型，那我们再使用 += 看看

当使用 += 时并没有报错，因为使用 += 其含有强转转换类型，a += 1，其因为 a = (int)(a+1)。所以也就说其类型不会发生改变(上面第2规则)，但可能会损失精度。

其他类型都是一样的，可以安装 += 推出，这里博主就不多叙述了。

六、条件运算符(三目运算符)

1. 表达式1 ? 表达式2 : 表达式3，当表达式 1 为 true 时，执行表达式2，为false 时执行表达式3

例：

public class Test5 {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int ret = a > b ? a : b;
        System.out.println(ret);
    }
}

ret的结果为：

七、移位运算符

   1. 左移<<

1. 对二进制进行左移，最左侧的不要，右侧补0。

public class Test6 {
    public static void main(String[] args) {
        int a = 1;
        a = a << 1;
        System.out.println(a);
    }
}

   2. 右移 >>

1. 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

例：

public class Test6 {
    public static void main(String[] args) {
        int a = 2;
        a = a >> 1;
        System.out.println(a);
    }
}

根据左移可知右移的结果为1

负数进行右移：

public class Test6 {
    public static void main(String[] args) {
        int a = -2;
        a = a >> 1;
        System.out.println(a);
    }
}

   3. 无符号右移 >>>

1. 最右侧位不要了, 最左侧补0，与右移 >>不同的是无符号右移不考虑符号位，都是补0。

例：

public class Test6 {
    public static void main(String[] args) {
        int a = -2;
        a = a >>> 1;
        System.out.println(a);
    }
}

好了，Java的运算符就讲到这里了，喜欢的可以点个赞哦。如有发现错可以私聊博主进行修改，多谢各位大佬 ^ _ ^.