java运算符 与（&）、非（~）、或（|）、异或（^） 及移位运算符

 

Java运算符大致分为逻辑运算符(&&,||,！)、算数运算符（+, -, *, / ,+=）、位运算符（^,|,&）、其他运算符（三元运算符）

 下面将各符号名称列出：

&（按位与）

&&（逻辑与）

|（按位或）

||（逻辑或）

^（异或运算符）

<<（左移运算符）

>>（右移运算符）

~（取反运算符）

>>>（无符号右移运算符）

&（按位与）

位运算符

&按位与的运算规则是将两边的数转换为二进制位，然后运算最终值，运算规则即(两个为真才为真)1&1=1 , 1&0=0 , 0&1=0 , 0&0=0

3的二进制位是0000 0011 ， 5的二进制位是0000 0101 ， 那么就是011 & 101，由按位与运算规则得知，001 & 101等于0000 0001，最终值为1

7的二进制位是0000 0111，那就是111 & 101等于101，也就是0000 0101，故值为5

&&（逻辑与）

逻辑运算符

&&逻辑与也称为短路逻辑与，先运算&&左边的表达式，一旦为假，后续不管多少表达式，均不再计算，一个为真，再计算右边的表达式，两个为真才为真。

|（按位或）

位运算符

|按位或和&按位与计算方式都是转换二进制再计算，不同的是运算规则(一个为真即为真)1|0 = 1 , 1|1 = 1 , 0|0 = 0 , 0|1 = 1

6的二进制位0000 0110 , 2的二进制位0000 0010 , 110|010为110，最终值0000 0110，故6|2等于6

||（逻辑或）

逻辑运算符

逻辑或||的运算规则是一个为真即为真，后续不再计算，一个为假再计算右边的表达式。

^（异或运算符）

位运算符

^异或运算符顾名思义，异就是不同，其运算规则为1^0 = 1 , 1^1 = 0 , 0^1 = 1 , 0^0 = 0

5的二进制位是0000 0101 ， 9的二进制位是0000 1001，也就是0101 ^ 1001,结果为1100 , 00001100的十进制位是12

<<（左移运算符）

位运算符

5<<2的意思为5的二进制位往左挪两位，右边补0，5的二进制位是0000 0101 ， 就是把有效值101往左挪两位就是0001 0100 ，正数左边第一位补0，负数补1，等于乘于2的n次方（5* (2*2)），十进制位是20

>>（右移运算符）

位运算符

凡位运算符都是把值先转换成二进制再进行后续的处理，5的二进制位是0000 0101，右移两位就是把101左移后为0000 0001，正数左边第一位补0，负数补1，等于除于2的n次方(5/(2*2))，结果为1

~（取反运算符）

位运算符

取反就是1为0,0为1,5的二进制位是0000 0101，取反后为1111 1010，值为-6

>>>（无符号右移运算符）

正数无符号右移

无符号右移运算符和右移运算符的主要区别在于负数的计算，因为无符号右移是高位补0，移多少位补多少个0。

15的二进制位是0000 1111 ， 右移2位0000 0011，结果为3

负数无符号右移

-6的二进制是6的二进制取反再加1,6的二进制也就是0000 0000 0000 0000 0000 0000 0000 0110，取反后加1为1111 1111 1111 1111 1111 1111 1111 1010，右移三位0001 1111 1111 1111 1111 1111 1111 1111

至于这个负数的无符号右移为什么是4个字节位的移动，我也不太清楚，还望高手赐教，有所纰漏，欢迎留言，谢谢。

转载声明： https://cloud.tencent.com/developer/article/1338265

---

原文出自： https://www.cnblogs.com/yesiamhere/p/6675067.html

最近看HashMap源码，遇到了这样一段代码：

1     static final int hash(Object key) {
2         int h;
3         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
4     }

于是我整理学习了以下知识：
1.十进制转二进制

原理：给定的数循环除以2，直到商为0或者1为止。将每一步除的结果的余数记录下来，然后反过来就得到相应的二进制了。

比如8转二进制，第一次除以2等于4（余数0），第二次除以2等于2（余数0），第三次除以2等于1（余数0），最后余数1，得到的余数依次是0 0 0 1 ，

反过来就是1000，计算机内部表示数的字节长度是固定的，比如8位，16位，32位。所以在高位补齐，java中字节码是8位的，所以高位补齐就是00001000.

写法位（8）10=（00001000）2；

代码实现：

 1 package sourceCode.hashMap;
 2 
 3 public class mapHashCodeTest {
 4     public static void main(String[] args) {
 5         String str = toBinary(8);
 6         System.out.println(str);
 7     }
 8 
 9     static String toBinary(int num) {
10         String str = "";
11         while (num != 0) {
12             str = num % 2 + str;
13             num = num / 2;
14         }
15         return str;
16     }
17 
18 }

运行结果：1000

2.二进制转十进制

计算也很简单，比如8的二进制表示位00001000，去掉补齐的高位就是1000.此时从个位开始计算2的幂（个位是0，依次往后推）乘以对应位数上的数，然后得到的值想加

于是有了，（2的0次幂）*0+（2的1次幂）*0+（2的2次幂）*0+（2的3次幂）*1 = 8

代码实现，直接调用Integer.parseInt("",2);

1 System.out.println(Integer.parseInt("1000",2));

运行结果：8

3.位异或运算（^）

运算规则是：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。

比如：8^11.

8转为二进制是1000，11转为二进制是1011.从高位开始比较得到的是：0011.然后二进制转为十进制，就是Integer.parseInt("0011",2)=3;

 

延伸：

4.位与运算符（&）

运算规则：两个数都转为二进制，然后从高位开始比较，如果两个数都为1则为1，否则为0。

比如：129&128.

129转换成二进制就是10000001，128转换成二进制就是10000000。从高位开始比较得到，得到10000000，即128.

 

5.位或运算符（|）

运算规则：两个数都转为二进制，然后从高位开始比较，两个数只要有一个为1则为1，否则就为0。

比如：129|128.

129转换成二进制就是10000001，128转换成二进制就是10000000。从高位开始比较得到，得到10000001，即129.

 

6.位非运算符（~）

运算规则：如果位为0，结果是1，如果位为1，结果是0.

比如：~37

在Java中，所有数据的表示方法都是以补码的形式表示，如果没有特殊说明，Java中的数据类型默认是int,int数据类型的长度是8位，一位是四个字节，就是32字节，32bit.

8转为二进制是100101.

补码后为： 00000000 00000000 00000000 00100101

取反为：    11111111 11111111 11111111 11011010

因为高位是1，所以原码为负数，负数的补码是其绝对值的原码取反，末尾再加1。

因此，我们可将这个二进制数的补码进行还原： 首先，末尾减1得反码：11111111 11111111 11111111 11011001 其次，将各位取反得原码：

00000000 00000000 00000000 00100110，此时二进制转原码为38

所以~37 = -38. 

 

---

今天在对同事的代码进行code review的时候，见到一个比较好玩的写法。“flag &= false；”，乍一看，还感觉他写错了，但是程序可以正常运行，赶紧去百度，看一下这个写法到底是怎么一回事，原来这个与平时常见的-=，+=等等是一样的，只不过平时用的比较少而已了，这个还真的是一个提升屌丝情怀的利器，至少不能见到这种写法不知道是什么意思吧。

代码如下：

public class MainMethod {
    public static void main(String[] args) {
        boolean flag = true;
        flag &= true;
        System.out.println("true\t&=\ttrue\t==>\t" + flag);
        flag = true;
        flag &= false;
        System.out.println("true\t&=\tfalse\t==>\t" + flag); 
        flag = false;
        flag &= true;
        System.out.println("false\t&=\ttrue\t==>\t" + flag); 
        flag = false;
        flag &= false;
        System.out.println("false\t&=\tfalse\t==>\t" + flag+"\n"); 
        
        flag = true;
        flag |= true;
        System.out.println("true\t|=\ttrue\t==>\t" + flag);
        flag = true;
        flag |= false;
        System.out.println("true\t|=\tfalse\t==>\t" + flag); 
        flag = false;
        flag |= true;
        System.out.println("false\t|=\ttrue\t==>\t" + flag); 
        flag = false;
        flag |= false;
        System.out.println("false\t|=\tfalse\t==>\t" + flag+"\n"); 
        
        System.out.println("^=  相同为真，不同为假");
        flag = true;
        flag ^= true;
        System.out.println("true\t^=\ttrue\t==>\t" + flag);
        flag = true;
        flag ^= false;
        System.out.println("true\t^=\tfalse\t==>\t" + flag); 
        flag = false;
        flag ^= true;
        System.out.println("false\t^=\ttrue\t==>\t" + flag); 
        flag = false;
        flag ^= false;
        System.out.println("false\t^=\tfalse\t==>\t" + flag); 
    }
}

执行结果如下：

&= 同真为真， 一假为假

true    &=    true    ==>    true
true    &=    false    ==>    false
false    &=    true    ==>    false
false    &=    false    ==>    false

|= 同假为假  一真为真
true    |=    true    ==>    true
true    |=    false    ==>    true
false    |=    true    ==>    true
false    |=    false    ==>    false
^=  相同为假，不同为真
true    ^=    true    ==>    false
true    ^=    false    ==>    true
false    ^=    true    ==>    true
false    ^=    false    ==>    false
--------------------- 
作者：陈字文 
原文：https://blog.csdn.net/ziwen00/article/details/40656897 

---

原文：https://www.cnblogs.com/hongten/p/hongten_java_yiweiyunsuangfu.html

java中有三种移位运算符

<<      :     左移运算符，num << 1,相当于num乘以2

>>      :     右移运算符，num >> 1,相当于num除以2

>>>    :     无符号右移，忽略符号位，空位都以0补齐

下面来看看这些移位运算都是怎样使用的

/**
 * 
 */
package com.b510.test;

/**
 * @author Jone Hongten
 * @create date：2013-11-2
 * @version 1.0
 */
public class Test {

    public static void main(String[] args) {
        int number = 10;
        //原始数二进制
        printInfo(number);
        number = number << 1;
        //左移一位
        printInfo(number);
        number = number >> 1;
        //右移一位
        printInfo(number);
    }
    
    /**
     * 输出一个int的二进制数
     * @param num
     */
    private static void printInfo(int num){
        System.out.println(Integer.toBinaryString(num));
    }
}

运行结果为：

1010
10100
1010

我们把上面的结果对齐一下：

43210      位数
--------
 1010      十进制：10     原始数         number
10100      十进制：20     左移一位       number = number << 1;
 1010      十进制：10     右移一位       number = number >> 1;

看了上面的demo，现在是不是对左移和右移了解了很多了呢

对于：>>>

 无符号右移，忽略符号位，空位都以0补齐

value >>> num     --   num 指定要移位值value 移动的位数。

无符号右移的规则只记住一点：忽略了符号位扩展，0补最高位  无符号右移运算符>>> 只是对32位和64位的值有意义