Java中的位运算

//Java中的位运算
/*计算机由复杂电子元器件构成，一个电子元器件有带电和不带电的两种状态，1和0
多个这样的元器件的组合可以表示更多状态，也就是可以表示更多的数据，
一个元器件可以表示一位(bit)数据，这种表示数据的方式称为2进制
在实际的电子设备中，将8个元器件组合在一起，形成一个单元，这样的单元叫做一个字节(byte)
一个字节能表示2^8＝256个数，即0－255
2个字节能表示2^16个数，即0－2^16-1
4个字节能表示2^32个数，即0－2^32-1
一个字节(byte)由8个二进位(bit)组成，
最右边的称为最低有效位，最左边的称为最高有效位
每一个二进位的值都是0或1*/
/*在计算机中常采用16位进制的方法，因为二进制书写太长，容易出错
16进制的f代表十进制中的15，在二进制中需要4位(bit)1111来书写
16进制中的ff代表十进制的255，在二进制中需要8位(bit)11111111来书写*/
//在计算机中只有数值，可以用数值表示不同的含义，如内存的数值可代表不同的含义

//原码、反码和补码
/*原码：将最高位作为符号位(1为负，0为正），其余各位代表数值本身的绝对值（二进制表示）
以一个字节的数值为例：
＋7：00000111
－7：10000111
而问题在于：
＋0：00000000
－0：10000000
这样表示数值不唯一，因而在计算机中很少采用原码*/
/*反码：一个数如果为正，则它的反码和原码相同，如果为负，符号位为1，其余各位对原码取反
如：
＋7的原码是：00000111
＋7的反码是：00000111
－7的原码是：10000111
－7的反码是：11111000
问题还是：
＋0的反码是：00000000
－0的反码是：11111111*/
/*补码：利用溢出，我们可以将减法变成加法//主要就是怎么操作、运算，使结果满足我们的需要
对于十进制，如果要从9得到结果5，我们可以用减法：
9－4＝5
因为4＋6＝10，我们将6作为4的补数，将上式的减法改成加法：
9＋6＝15
去掉高位1（也就是减去10），得到结果5

对于16进制，如果从C得到结果5，我们可以用减法：
C－7＝5
因为7＋9＝16，我们将9作为7的补数，将上式的减法改成加法：
C＋9＝15（十进制中21）
去掉高位1（也就是减去16），得到结果5*/
/*在计算机中，如果我们采用1个字节来表示一个数，则这个字节有8位(bit)
超过8位（bit）就进1，在内存中情况为：
1 00000000
进位1被丢弃*/
/*补码：如果一个数如果为正，则它的原码、反码和补码相同
如果一个数为负，则符号位为1，其余各位对原码取反，然后整个数加1
为了简单起见，以一个字节来表示一个整数：
＋7的原码为：00000111
＋7的补码为：00000111
－7的原码为：10000111
－7的补码为：11111000//第一步取反
                  ＋1//第二步加1
             －－－－
             11111001//得到结果
0的补码表示为:
＋0的补码为：00000000
－0的补码为：10000000
第一步 取反：11111111
第二步 加1：100000000
第三步进位1被丢弃，得到结果00000000与＋0的表示相同*/
/*已知一个负数的补码，转换成十进制数，步骤为：
1.先对各位取反
2.将其转换成十进制数
3.加上符号，再减去1
例如：11111010，最高位是1，是负数，先对各位取反，变成00000101；
转换成十进制数5，加上符号，变成－5，再减去1，变成－6*/

//位运算符（是对位(bit)进行运算，而不是对数值进行运算）
/*Java中有4个位运算符:
  &  按位与
  |  按位或
  ^  按位异或
  ~  按位取反
1.按位与
  01101101
&
  00110111
  －－－－
  00100101
结论：按位与，只有壹(1)壹(1)与操作为1
2.按位或
   01101101
|
   00110111
   －－－－
   01111111
结论：按位或，只有零(0)零(0)或操作为0
3.按位异或
   01101101
^
   00110111
   －－－－
   01011010
结论：按位异或，只有零(0)壹（1）或者壹（1）零（0）异或操作为1
4.按位取反
~ 01101101
   －－－－
   10010010
结论：按位取反，只要将1变成0，0变成1

//Java中的移位运算符
/*java中三个移位运算符：
左移:<<
带符号右移：>>
无符号右移:>>>


class count
{
public static void main(String[] argus)
{
int i1=-1;
int i2=i1<<2;
System.out.println(i1);
System.out.println(i2);
int i3=0xffffffff;
int i4=i3<<2;
System.out.println(i3);
System.out.println(i4);

}
}

 

 

Java的位运算（bitwise operators）直接对整数类型的位进行操作，这些整数类型包括long、int、short、char和 byte，位运算符具体如下表：

运算符

说明

<<

左移位，在低位处补0

>>

右移位，若为正数则高位补0，若为负数则高位补1

>>>

无符号右移位，无论正负都在高位补0

&

与（AND），对两个整型操作数中对应位执行布尔代数，两个位都为1时输出1，否则0。

|

或（OR），对两个整型操作数中对应位执行布尔代数，两个位都为0时输出0，否则1。

~

非（NOT），一元运算符。

^

异或（XOR），对两个整型操作数中对应位执行布尔代数，两个位相等0，不等1。

<<=

左移位赋值。

>>=

右移位赋值。

>>>=

无符号右移位赋值。

&=

按位与赋值。

|=

按位或赋值。

^=

按位异或赋值。

左移位（<<）

程序：

public class LeftMoving{

    public static void main(String[] args){

           System.out.println("5<<3="+(5<<3));

    }

}

输出结果：

5<<3=40

计算过程：

0000 0000 0000 0000 0000 0000 0000 0101         ? 5

0000 0000 0000 0000 0000 0000 0010 1000         ? 40

右移位（>>）

正数

程序：

public class PlusRightMoving{

    public static void main(String[] args){

           System.out.println("5>>1="+(5>>1));

    }

}

输出结果：

5>>1=2

计算过程：

0000 0000 0000 0000 0000 0000 0000 0101         ? 5

0000 0000 0000 0000 0000 0000 0000 0010         ? 2

负数

程序：

public class NegativeRightMoving{

    public static void main(String[] args){

           System.out.println("-5>>1="+(-5>>1));

    }

}

输出结果：

-5>>1=-3

计算过程：

1111 1111 1111 1111 1111 1111 1111 1011         ? -5

1111 1111 1111 1111 1111 1111 1111 1101         ? -3

无符号右移位（>>>）

程序：

public class UnsignedRightMoving{

    public static void main(String[] args){

System.out.println("-5>>>1="+(-5>>>1));

    }

}

输出结果：

-5>>>1=2147483645

计算过程：

1111 1111 1111 1111 1111 1111 1111 1011         ? -5

       0111 1111 1111 1111 1111 1111 1111 1101          ? 2147483645

首先复习一下Java中的基本数据类型的相关知识。

数据类型

大小

最小值

最大值

boolean

byte

8-bit

-128

+127

char

16-bit

Unicode 0

Unicode 2¹⁶-1

short

16-bit

-2¹⁵

+2¹⁵-1

int

32-bit

-2³¹

+2³¹-1

float

32-bit

IEEE754

IEEE754

long

64-bit

-2⁶³

2⁶³-1

double

64-bit

IEEE754

IEEE754

void

这里包括了float和double两个浮点型，在本文中对其不予考虑，因为位运算是针对整型的。进行位操作时，除long型外，其他类型会自动转成int型，转换之后，可接受右操作数长度为32。进行位运算时，总是先将短整型和字节型值转换成整型值再进行移位操作的。

程序：

public class ByteLeftMoving{

public static void main(String[] args){

    byte b = 127;

           System.out.println("b<<3="+(b<<3));

        System.out.println("(byte)(b<<3)="+(byte)(b<<3));

    }

}

输出结果：

b<<3=1016

(byte)(b<<3)=-8

程序：

public class CharLeftMoving{

public static void main(String[] args){

        char c = 'l';

           System.out.println("c<<3="+(c<<3));

        System.out.println("(char)(c<<3)="+(char)(c<<3));

    }

}

输出结果：

c<<3=864

(char)(c<<3)=?

以上两个例子全部编译通过，由此可以看出，当byte和char进行移位运算时不会发生错误，并且均按照整型进行计算，当计算结果超出byte或是char所能表示的范围时则进行相应的转换（分别输出了结果-8和?）。

位运算中的操作数

在进行移位运算时要注意整型和长整型在内存中的位数（整型是32位，长整型是64位），如果移位操作数超出了该位数则取模计算，例如：int型数据是32位的，如果左移35位是什么结果？

程序：

public class LeftMoving{

    public static void main(String[] args){

           System.out.println("5<<35="+(5<<35));

    }

}

输出结果：

5<<35=40 

该结果与5<<3完全相同。

无论正数、负数，它们的右移、左移、无符号右移 32位都是其本身，比如 -5<<32=-5、-5>>32=-5、-5>>>32=-5。

一个有趣的现象是，把 1 左移 31 位再右移 31位，其结果为 -1。

计算过程如下：

0000 0000 0000 0000 0000 0000 0000 0001

1000 0000 0000 0000 0000 0000 0000 0000

1111 1111 1111 1111 1111 1111 1111 1111

位运算要求操作数为整数，操作数不能是字符串也不能是小数。

如下列程序：

public class BitMath{

    public static void main(String[] args){

        String s = "Hello";

        long l = 99;

        double d = 1.11;

        int i = 1;

        int j = 0;

        System.out.println("j<<s="+j<<s);    //编译错误语句

        System.out.println("j<<d="+j<<d);    //编译错误语句

        System.out.println("i<<j="+i<<j);    //编译可以通过

        System.out.println("i<<l="+i<<l);    //编译可以通过

    }

}

由于位运算是二进制运算，不要与一些八进制数搞混，java中二进制数没有具体的表示方法。

public class BitMath{

    public static void main(String[] args){

        System.out.println("010|4="+(010|4));

    }

}

输出结果：

010|4=12

计算过程：

0000 0000 0000 0000 0000 0000 0000 1000   ?8

0000 0000 0000 0000 0000 0000 0000 0100   ?4

进行“或”计算结果为：

0000 0000 0000 0000 0000 0000 0000 1100   ?12

当位运算中遇见负数，必须把它转成补码（不知道什么是补码的补习功课去）再进行计算，而不是使用原码。

程序：

public class BitMath{

    public static void main(String[] args){

        try {

            int x = -7;

            System.out.println("x>>1="+(x>>1));

} catch(Exception e) {

            System.out.println("Exception");

        }

    }

}

输出结果：

x>>1=-4

计算过程：

1111 1111 1111 1111 1111 1111 1111 1001   ?-7

1111 1111 1111 1111 1111 1111 1111 1100   ?-4

public class BitMath{

    public static void main(String[] args){

        int i = 1;

        int j = -1;

        System.out.println("1>>>31="+(i>>>31));

        System.out.println("-1>>31="+(j>>31));

    }

}

输出结果：

1>>>31=0

-1>>31=-1

程序：

public class BitMath{

    public static void main(String[] args){

        int a = 1;

       a <<= 31;

        a >>= 31;

        a >>= 1;       

        System.out.println("a="+a);

        int b = 1;

        b <<= 31;

        b >>= 31;

        System.out.println("b="+b);

        int c = 1;

        c >>= 31;

        c <<= 31;

        System.out.println("c="+c);

    }

}

输出结果：

a=-1

b=-1

c=0

计算过程：

0000 0000 0000 0000 0000 0000 0000 0001   ?a=1

1000 0000 0000 0000 0000 0000 0000 0000   ?a=a<<31后，这里被当作是负数

1111 1111 1111 1111 1111 1111 1111 1111   ?a=a>>31后，结果为-1

1111 1111 1111 1111 1111 1111 1111 1111   ?a=a>>1后，结果仍为-1

0000 0000 0000 0000 0000 0000 0000 0001   ?c=1

0000 0000 0000 0000 0000 0000 0000 0000   ?c=c>>31后为0

0000 0000 0000 0000 0000 0000 0000 0000   ?0左移31位仍为0

 

 

http://fosbin.blog.163.com/blog/static/18274600720114272932530/

http://macromolecular.blog.sohu.com/82549355.html