Java位运算符学习

Java中的位运算符有如下几类

  • 左移 <<
  • 又移 >>
  • 无符号右移 >>>
  • 位与 &
  • 位或 |
  • 位非 ~
  • 位异或 ^

左移 <<

public static void main(String[] args)
    {
        System.out.println(Integer.toBinaryString(10));
        System.out.println(10 << 2);
        System.out.println(Integer.toBinaryString(10 << 2));
    }

在java中对一个数字左移n位，其实就是给该数字乘以2的n次方，比如10<<2，就是给10乘以2的平方，得到40。
那么二进制的方式是怎么实现的呢？上述代码输出结果如下：

1010
40
101000
//补全 int 32位十进制，如下
0000 0000 0000 0000 0000 0000 0000 1010
40
0000 0000 0000 0000 0000 0000 0010 1000
可以看出是将1010左移两位，低位补零所得。

因为Java中，int数字有符号，并且有长度限制，所能表示的范围为-2^31 ~ 2^31 -1（-2147483648~2147483647），因此如果左移所得结果超过2^37 - 1，将会变成负数；负数左移超过 -2^37 之后将会变成0，-2^37无论左移多少（除过32以及32的倍数位）位，结果始终为0。

public static void main(String[] args)
    {
        System.out.println(Integer.toBinaryString(2147483647));
        System.out.println(2147483647 << 1);
        System.out.println(Integer.toBinaryString(2147483647 << 1));
        System.out.println("-------------------------------------");
        System.out.println(Integer.toBinaryString(-2147483648));
        System.out.println(-2147483648 << 1);
        System.out.println(-2147483648 << 100);
        System.out.println(Integer.toBinaryString(-2147483648 << 100));
    }

结果如下：

1111111111111111111111111111111
-2
11111111111111111111111111111110
-------------------------------------
10000000000000000000000000000000
0
0
0

注意1左移31位所得既是int所能表示的做小整数，但是1左移32位不会得到0，而是1，不同于直接将-2147483648左移1位

public static void main(String[] args)
    {
        System.out.println(1 << 31);
        System.out.println(Integer.toBinaryString(1 << 31));
        System.out.println(-2147483648 << 1);
        System.out.println(1 << 32);
    }

-2147483648
10000000000000000000000000000000
0
1

任一数字左移32（或者32倍数）位将得到其本身

public static void main(String[] args)
    {
        System.out.println(1 << 32);
        System.out.println(2147483647 << 32);
        System.out.println(-1 << 32);
        System.out.println(-2147483648 << 64);
    }

1
2147483647
-1
-2147483648

右移 >>

在java中对一个数字右移n位，其实就是给该数字除以2的n次方，向下取整。正整数右移取到0之后，右移任何（除了32以及32的倍数）位，都是0；负整数右移得到-1之后，右移任何（除了32以及32的倍数）位，都是-1。
任一数字右移32（或者32的倍数）位将得到其本身
比如10>>2，就是10除以2的平方，取整得到2，-10>>2，就是-10除以2的平方向下取整，得到-3。

public static void main(String[] args)
    {
        System.out.println("1 >> 1 : " + (1 >> 1));
        System.out.println("1 >> 20 : " + (1 >> 20));
        System.out.println("1 >> 32 : " + (1 >> 32));
        System.out.println("10 >> 2 : " + (10 >> 2));
        System.out.println("10 >> 4 : " + (10 >> 4));
        System.out.println("10 >> 30 : " + (10 >> 30));
        System.out.println("10 >> 64 : " + (10 >> 64));
        System.out.println("---------------------------------------");
        System.out.println("-1 >> 2 : " + (-1 >> 2));
        System.out.println("-1 >> 20 : " + (-1 >> 20));
        System.out.println("-1 >> 32 : " + (-1 >> 32));
        System.out.println("-10 >> 2 : " + (-10 >> 2));
        System.out.println("-10 >> 3 : " + (-10 >> 3));
        System.out.println("-10 >> 4 : " + (-10 >> 4));
        System.out.println("-10 >> 30 : " + (-10 >> 30));
        System.out.println("-10 >> 96 : " + (-10 >> 96));
        
    }

1 >> 1 : 0
1 >> 20 : 0
1 >> 32 : 1
10 >> 2 : 2
10 >> 4 : 0
10 >> 30 : 0
10 >> 64 : 10
---------------------------------------
-1 >> 2 : -1
-1 >> 20 : -1
-1 >> 32 : -1
-10 >> 2 : -3
-10 >> 3 : -2
-10 >> 4 : -1
-10 >> 30 : -1
-10 >> 96 : -10

无符号右移 >>>

通常所说的右移即有符号右移，对于正整数来说，有符号右移与无符号右移是一样的，对于负整数来说，有符号右移高位补1，无符号右移高位补0。
任一数字无符号右移32（或者32的倍数）位，得到其本身

public static void main(String[] args)
    {
        System.out.println("10 :       " + Integer.toBinaryString(10));
        System.out.println("10 >> 1  : " + Integer.toBinaryString(10 >> 1) + " : " + (10 >> 1));
        System.out.println("10 >>> 1 : " + Integer.toBinaryString(10 >>> 1) + " : " +  (10 >>> 1) );    
        System.out.println("10 >> 2 :  " + Integer.toBinaryString(10 >> 2) + " : " +  (10 >> 2) );  
        System.out.println("10 >>> 2 : " + Integer.toBinaryString(10 >>> 2) + " : " +  (10 >>> 2) );    
        System.out.println("10 >>> 32 : " + Integer.toBinaryString(10 >>> 32) + " : " +  (10 >>> 32) ); 
        System.out.println("--------------------------------------------------");
        System.out.println("-10 :       " + Integer.toBinaryString(-10));
        System.out.println("-10 >> 1  : " + Integer.toBinaryString(-10 >> 1) + " : " + (-10 >> 1));
        System.out.println("-10 >>> 1 : " + Integer.toBinaryString(-10 >>> 1) + " : " +  (-10 >>> 1) ); 
        System.out.println("-10 >> 2 :  " + Integer.toBinaryString(-10 >> 2) + " : " +  (-10 >> 2) );       
        System.out.println("-10 >>> 2 : " + Integer.toBinaryString(-10 >>> 2) + " : " +  (-10 >>> 2) );     
        System.out.println("-10 >>> 32 :" + Integer.toBinaryString(-10 >>> 32) + " : " +  (-10 >>> 32) );       
    }

10 :       1010
10 >> 1  : 101 : 5
10 >>> 1 : 101 : 5
10 >> 2 :  10 : 2
10 >>> 2 : 10 : 2
10 >>> 32 : 1010 : 10
--------------------------------------------------
-10 :       11111111111111111111111111110110
-10 >> 1  : 11111111111111111111111111111011 : -5
-10 >>> 1 : 1111111111111111111111111111011 : 2147483643
-10 >> 2 :  11111111111111111111111111111101 : -3
-10 >>> 2 : 111111111111111111111111111101 : 1073741821
-10 >>> 32 :11111111111111111111111111110110 : -10

如上实验，-10>>1位，与-10>>>1所得二进制码相差一位，其实是高位补0，补全32位如下：

-10 :       11111111111111111111111111110110
-10 >> 1  : 11111111111111111111111111111011 : -5
-10 >>> 1 : 01111111111111111111111111111011 : 2147483643
-10 >> 2 :  11111111111111111111111111111101 : -3
-10 >>> 2 : 00111111111111111111111111111101 : 1073741821
-10 >>> 32 :11111111111111111111111111110110 : -10
位与 &

位与，是将数字在二进制形式下，并且都补齐到32位，然后逐一对两个数的每一位进行比较，相同则得1，否则得0，最终得到的二进制为结果。

  1. 所有数字与0位与运算都得到0；
  2. 所有数字与-1位与运算都得到数字本身；
  3. 所有正数与231-1位与运算都得到本身，与-231位与都得到0；
  4. 所有负数与231-1位与运算都得到231+负数，与-231位与都得到-231；
public static void main(String[] args)
    {
        System.out.println("2147483647    :       " + Integer.toBinaryString(2147483647));
        System.out.println("-2147483648   :       " + Integer.toBinaryString(-2147483648));
        System.out.println("-1            :       " + Integer.toBinaryString(-1));
        System.out.println("0             :       " + Integer.toBinaryString(0));
        System.out.println("---------------------------------------------------------");
        
        System.out.println("10   :       " + Integer.toBinaryString(10));
        System.out.println("1    :       " + Integer.toBinaryString(1));
        System.out.println("10&1 :       " + Integer.toBinaryString(10&1) + "|" + (10&1));
        System.out.println("10&-8:       " + Integer.toBinaryString(10&-8) + "|" + (10&-8));
        System.out.println("---------------------------------------------------------");
        System.out.println("-10   :       " + Integer.toBinaryString(-10));
        System.out.println("-2    :       " + Integer.toBinaryString(-2));
        System.out.println("1     :       " + Integer.toBinaryString(1));
        System.out.println("-10&-2:       " + Integer.toBinaryString(-10&-2) + "|" + (-10&-2));
        System.out.println("-10&1 :       " + Integer.toBinaryString(-10&1) + "|" + (-10&1));
        System.out.println("---------------------------------------------------------");
        System.out.println("10&-1:       " + Integer.toBinaryString(10&-1) + "|" + (10&-1));
        System.out.println("100&-1:       " + Integer.toBinaryString(100&-1) + "|" + (100&-1));
        System.out.println("2147483647&-1:       " + Integer.toBinaryString(2147483647&-1) + "|" + (2147483647&-1));
        System.out.println("-2147483648&-1:       " + Integer.toBinaryString(-2147483648&-1) + "|" + (-2147483648&-1));
        System.out.println("---------------------------------------------------------");
        System.out.println("10&0:       " + Integer.toBinaryString(10&0) + "|" + (10&0));
        System.out.println("-10&0:       " + Integer.toBinaryString(-10&0) + "|" + (-10&0));
        System.out.println("2147483647&0:       " + Integer.toBinaryString(2147483647&0) + "|" + (2147483647&0));
        System.out.println("-2147483648&0:       " + Integer.toBinaryString(-2147483648&0) + "|" + (-2147483648&0));
        System.out.println("---------------------------------------------------------");
        System.out.println("2147483647&-2147483648:       " + Integer.toBinaryString(2147483647&-2147483648) + "|" + (2147483647&-2147483648));
        System.out.println("-10&2147483647 :       " + Integer.toBinaryString(-10&2147483647) + "|" + (-10&2147483647));
        System.out.println("-123&2147483647 :       " + Integer.toBinaryString(-123&2147483647) + "|" + (-123&2147483647));
        System.out.println("10&2147483647 :       " + Integer.toBinaryString(10&2147483647) + "|" + (10&2147483647));
        System.out.println("-10&-2147483648 :       " + Integer.toBinaryString(-10&-2147483648) + "|" + (-10&-2147483648));
        System.out.println("-123&-2147483648 :       " + Integer.toBinaryString(-123&-2147483648) + "|" + (-123&-2147483648));
        System.out.println("10&-2147483648 :       " + Integer.toBinaryString(10&-2147483648) + "|" + (10&-2147483648));
    }

2147483647    :       1111111111111111111111111111111
-2147483648   :       10000000000000000000000000000000
-1            :       11111111111111111111111111111111
0             :       0
---------------------------------------------------------
10   :       1010
1    :       1
10&1 :       0|0
10&-8:       1000|8
---------------------------------------------------------
-10   :       11111111111111111111111111110110
-2    :       11111111111111111111111111111110
1     :       1
-10&-2:       11111111111111111111111111110110|-10
-10&1 :       0|0
---------------------------------------------------------
10&-1:       1010|10
100&-1:       1100100|100
2147483647&-1:       1111111111111111111111111111111|2147483647
-2147483648&-1:       10000000000000000000000000000000|-2147483648
---------------------------------------------------------
10&0:       0|0
-10&0:       0|0
2147483647&0:       0|0
-2147483648&0:       0|0
---------------------------------------------------------
2147483647&-2147483648:       0|0
-10&2147483647 :       1111111111111111111111111110110|2147483638
-123&2147483647 :       1111111111111111111111110000101|2147483525
10&2147483647 :       1010|10
-10&-2147483648 :       10000000000000000000000000000000|-2147483648
-123&-2147483648 :       10000000000000000000000000000000|-2147483648
10&-2147483648 :       0|0
位或 |

位或，是将数字在二进制形式下，并且都补齐到32位，然后逐一对两个数的每一位进行比较，任一数字该位为1则得1，否则得0，最终得到的二进制为结果。
注意以下结果与&的不同

  1. 所有数字与0位或运算都得到数字本身；
  2. 所有数字与-1位或运算都得到-1；
  3. 所有正数与231-1位或运算都得到231-1，与-231位或都得到-231+数字；
  4. 所有负数与231-1位或运算都得到-1，与-231位或都得到数字本身；
public static void main(String[] args)
    {
        System.out.println("2147483647    :       " + Integer.toBinaryString(2147483647));
        System.out.println("-2147483648   :       " + Integer.toBinaryString(-2147483648));
        System.out.println("-1            :       " + Integer.toBinaryString(-1));
        System.out.println("0             :       " + Integer.toBinaryString(0));
        System.out.println("---------------------------------------------------------");
        
        System.out.println("10   :       " + Integer.toBinaryString(10));
        System.out.println("1    :       " + Integer.toBinaryString(1));
        System.out.println("10|1 :       " + Integer.toBinaryString(10|1) + "|" + (10|1));
        System.out.println("10|-8:       " + Integer.toBinaryString(10|-8) + "|" + (10|-8));
        System.out.println("---------------------------------------------------------");
        System.out.println("-10   :       " + Integer.toBinaryString(-10));
        System.out.println("-2    :       " + Integer.toBinaryString(-2));
        System.out.println("1     :       " + Integer.toBinaryString(1));
        System.out.println("-10|-2:       " + Integer.toBinaryString(-10|-2) + "|" + (-10|-2));
        System.out.println("-10|1 :       " + Integer.toBinaryString(-10|1) + "|" + (-10|1));
        System.out.println("---------------------------------------------------------");
        System.out.println("10|-1:       " + Integer.toBinaryString(10|-1) + "|" + (10|-1));
        System.out.println("100|-1:       " + Integer.toBinaryString(100|-1) + "|" + (100|-1));
        System.out.println("2147483647|-1:       " + Integer.toBinaryString(2147483647|-1) + "|" + (2147483647|-1));
        System.out.println("-2147483648|-1:       " + Integer.toBinaryString(-2147483648|-1) + "|" + (-2147483648|-1));
        System.out.println("---------------------------------------------------------");
        System.out.println("10|0:       " + Integer.toBinaryString(10|0) + "|" + (10|0));
        System.out.println("-10|0:       " + Integer.toBinaryString(-10|0) + "|" + (-10|0));
        System.out.println("2147483647|0:       " + Integer.toBinaryString(2147483647|0) + "|" + (2147483647|0));
        System.out.println("-2147483648|0:       " + Integer.toBinaryString(-2147483648|0) + "|" + (-2147483648|0));
        System.out.println("---------------------------------------------------------");
        System.out.println("2147483647|-2147483648:       " + Integer.toBinaryString(2147483647|-2147483648) + "|" + (2147483647|-2147483648));
        System.out.println("-10|2147483647 :       " + Integer.toBinaryString(-10|2147483647) + "|" + (-10|2147483647));
        System.out.println("-123|2147483647 :       " + Integer.toBinaryString(-123|2147483647) + "|" + (-123|2147483647));
        System.out.println("10|2147483647 :       " + Integer.toBinaryString(10|2147483647) + "|" + (10|2147483647));
        System.out.println("-10|-2147483648 :       " + Integer.toBinaryString(-10|-2147483648) + "|" + (-10|-2147483648));
        System.out.println("-123|-2147483648 :       " + Integer.toBinaryString(-123|-2147483648) + "|" + (-123|-2147483648));
        System.out.println("10|-2147483648 :       " + Integer.toBinaryString(10|-2147483648) + "|" + (10|-2147483648));
    }

2147483647    :       1111111111111111111111111111111
-2147483648   :       10000000000000000000000000000000
-1            :       11111111111111111111111111111111
0             :       0
---------------------------------------------------------
10   :       1010
1    :       1
10|1 :       1011|11
10|-8:       11111111111111111111111111111010|-6
---------------------------------------------------------
-10   :       11111111111111111111111111110110
-2    :       11111111111111111111111111111110
1     :       1
-10|-2:       11111111111111111111111111111110|-2
-10|1 :       11111111111111111111111111110111|-9
---------------------------------------------------------
10|-1:       11111111111111111111111111111111|-1
100|-1:       11111111111111111111111111111111|-1
2147483647|-1:       11111111111111111111111111111111|-1
-2147483648|-1:       11111111111111111111111111111111|-1
---------------------------------------------------------
10|0:       1010|10
-10|0:       11111111111111111111111111110110|-10
2147483647|0:       1111111111111111111111111111111|2147483647
-2147483648|0:       10000000000000000000000000000000|-2147483648
---------------------------------------------------------
2147483647|-2147483648:       11111111111111111111111111111111|-1
-10|2147483647 :       11111111111111111111111111111111|-1
-123|2147483647 :       11111111111111111111111111111111|-1
10|2147483647 :       1111111111111111111111111111111|2147483647
-10|-2147483648 :       11111111111111111111111111110110|-10
-123|-2147483648 :       11111111111111111111111110000101|-123
10|-2147483648 :       10000000000000000000000000001010|-2147483638
位异或 ^

位异或，是将数字在二进制形式下，并且都补齐到32位，然后逐一对两个数的每一位进行比较，两个数字该位有一个为1另一个为0则得1，否则得0，最终得到的二进制为结果。

public static void main(String[] args)
    {
        System.out.println("2147483647    :       " + Integer.toBinaryString(2147483647));
        System.out.println("-2147483648   :       " + Integer.toBinaryString(-2147483648));
        System.out.println("-1            :       " + Integer.toBinaryString(-1));
        System.out.println("0             :       " + Integer.toBinaryString(0));
        System.out.println("---------------------------------------------------------");
        
        System.out.println("10   :       " + Integer.toBinaryString(10));
        System.out.println("1    :       " + Integer.toBinaryString(1));
        System.out.println("10^1 :       " + Integer.toBinaryString(10^1) + "|" + (10^1));
        System.out.println("10^-8:       " + Integer.toBinaryString(10^-8) + "|" + (10^-8));
        System.out.println("---------------------------------------------------------");
        System.out.println("-10   :       " + Integer.toBinaryString(-10));
        System.out.println("-2    :       " + Integer.toBinaryString(-2));
        System.out.println("1     :       " + Integer.toBinaryString(1));
        System.out.println("-10^-2:       " + Integer.toBinaryString(-10^-2) + "|" + (-10^-2));
        System.out.println("-10^1 :       " + Integer.toBinaryString(-10^1) + "|" + (-10^1));
        System.out.println("---------------------------------------------------------");
        System.out.println("10^-1:       " + Integer.toBinaryString(10^-1) + "|" + (10^-1));
        System.out.println("100^-1:       " + Integer.toBinaryString(100^-1) + "|" + (100^-1));
        System.out.println("2147483647^-1:       " + Integer.toBinaryString(2147483647^-1) + "|" + (2147483647^-1));
        System.out.println("-2147483648^-1:       " + Integer.toBinaryString(-2147483648^-1) + "|" + (-2147483648^-1));
        System.out.println("---------------------------------------------------------");
        System.out.println("10^0:       " + Integer.toBinaryString(10^0) + "|" + (10^0));
        System.out.println("-10^0:       " + Integer.toBinaryString(-10^0) + "|" + (-10^0));
        System.out.println("2147483647^0:       " + Integer.toBinaryString(2147483647^0) + "|" + (2147483647^0));
        System.out.println("-2147483648^0:       " + Integer.toBinaryString(-2147483648^0) + "|" + (-2147483648^0));
        System.out.println("---------------------------------------------------------");
        System.out.println("2147483647^-2147483648:       " + Integer.toBinaryString(2147483647^-2147483648) + "|" + (2147483647^-2147483648));
        System.out.println("-10^2147483647 :       " + Integer.toBinaryString(-10^2147483647) + "|" + (-10^2147483647));
        System.out.println("-123^2147483647 :       " + Integer.toBinaryString(-123^2147483647) + "|" + (-123^2147483647));
        System.out.println("10^2147483647 :       " + Integer.toBinaryString(10^2147483647) + "|" + (10^2147483647));
        System.out.println("-10^-2147483648 :       " + Integer.toBinaryString(-10^-2147483648) + "|" + (-10^-2147483648));
        System.out.println("-123^-2147483648 :       " + Integer.toBinaryString(-123^-2147483648) + "|" + (-123^-2147483648));
        System.out.println("10^-2147483648 :       " + Integer.toBinaryString(10^-2147483648) + "|" + (10^-2147483648));
    }

2147483647    :       1111111111111111111111111111111
-2147483648   :       10000000000000000000000000000000
-1            :       11111111111111111111111111111111
0             :       0
---------------------------------------------------------
10   :       1010
1    :       1
10^1 :       1011|11
10^-8:       11111111111111111111111111110010|-14
---------------------------------------------------------
-10   :       11111111111111111111111111110110
-2    :       11111111111111111111111111111110
1     :       1
-10^-2:       1000|8
-10^1 :       11111111111111111111111111110111|-9
---------------------------------------------------------
10^-1:       11111111111111111111111111110101|-11
100^-1:       11111111111111111111111110011011|-101
2147483647^-1:       10000000000000000000000000000000|-2147483648
-2147483648^-1:       1111111111111111111111111111111|2147483647
---------------------------------------------------------
10^0:       1010|10
-10^0:       11111111111111111111111111110110|-10
2147483647^0:       1111111111111111111111111111111|2147483647
-2147483648^0:       10000000000000000000000000000000|-2147483648
---------------------------------------------------------
2147483647^-2147483648:       11111111111111111111111111111111|-1
-10^2147483647 :       10000000000000000000000000001001|-2147483639
-123^2147483647 :       10000000000000000000000001111010|-2147483526
10^2147483647 :       1111111111111111111111111110101|2147483637
-10^-2147483648 :       1111111111111111111111111110110|2147483638
-123^-2147483648 :       1111111111111111111111110000101|2147483525
10^-2147483648 :       10000000000000000000000000001010|-2147483638
位非 ~

位非是单目运算符，是将数字在二进制形式下，并且都补齐到32位，然后逐一对每一位进行运算，1则的0，0则得1，最终得到的二进制为结果。

public static void main(String[] args)
    {
        System.out.println("2147483647    :       " + Integer.toBinaryString(2147483647));
        System.out.println("~2147483647   :       " + Integer.toBinaryString(~2147483647) + "|" + ~2147483647);
        System.out.println("-2147483648   :       " + Integer.toBinaryString(-2147483648));
        System.out.println("~-2147483648  :       " + Integer.toBinaryString(~-2147483648) + "|" + ~-2147483648);
        System.out.println("-1            :       " + Integer.toBinaryString(-1));
        System.out.println("~-1           :       " + Integer.toBinaryString(~-1) + "|" + ~-1);
        System.out.println("0             :       " + Integer.toBinaryString(0));
        System.out.println("~0            :       " + Integer.toBinaryString(~0) + "|" + ~0);
        System.out.println("10            :       " + Integer.toBinaryString(10));
        System.out.println("~10           :       " + Integer.toBinaryString(~10) + "|" + ~10);
        System.out.println("-10           :       " + Integer.toBinaryString(-10));
        System.out.println("~-10          :       " + Integer.toBinaryString(~-10) + "|" + ~-10);
        System.out.println("-100          :       " + Integer.toBinaryString(-100) );
        System.out.println("~-100         :       " + Integer.toBinaryString(~-100) + "|" + ~-100);
        System.out.println("100           :       " + Integer.toBinaryString(100) );
        System.out.println("~100          :       " + Integer.toBinaryString(~100) + "|" + ~100);
    }

2147483647    :       1111111111111111111111111111111
~2147483647   :       10000000000000000000000000000000|-2147483648
-2147483648   :       10000000000000000000000000000000
~-2147483648  :       1111111111111111111111111111111|2147483647
-1            :       11111111111111111111111111111111
~-1           :       0|0
0             :       0
~0            :       11111111111111111111111111111111|-1
10            :       1010
~10           :       11111111111111111111111111110101|-11
-10           :       11111111111111111111111111110110
~-10          :       1001|9
-100          :       11111111111111111111111110011100
~-100         :       1100011|99
100           :       1100100
~100          :       11111111111111111111111110011011|-101

自学试验，如有错误，欢迎拍砖。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,029评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,395评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,570评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,535评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,650评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,850评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,006评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,747评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,207评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,536评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,683评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,342评论 4赞 330
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,964评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,772评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,004评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,401评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,566评论 2赞 349