《JAVA中的二进制》

位运算：

首先说一下运算符

& 与运算     6&3=2

| 或运算     6|3=7

^ 异或运算   6^3=5

~ 反码       ~6=-7

>> 右移       3>>1  3/2=1

<< 左移       3<<2  3*2*2=12

>>> 无符号右移   3>>>1   3/2=1

二进制的优点

特定情况下，计算方便，速度快，被支持面广，如果用算数方法，速度慢，逻辑复杂

下面详细说一下运算符

&  与运算

两位全为1，结果才为1

0&0=0  0&1=0 1&0=0  1&1=1

举个例子   

51&5     0011 0011 & 0000 0101  =  00000001 所以51&5=1

与运算的特殊用法

（1）       清0。如果想将一个单元清0，即使其全部二进制为0，只要与一个各位都为0的数字相与，结果都为0.

（2）       可以取一个数中指定位

例如：设X=10101110  要取X的第四位，用X&0000 1111即可取到

方法就是：找一个数，对应X要取的位，该数的对应位为1，其余位为0，此数与X进行“与运算”可以得到X的指定位

|  或运算

只要一个为1，结果就为1

0|0=0  0|1=1 1|0=1  1|1=1

例如   51&5     0011 0011 & 0011 0111  =  00000001 所以51&5=55

或运算的特殊用法

常用来对一个数据的某些位 置为1

例如  将X=1010 0000 的第四位置为1，用X|0000 1111=1010 1111即可得到

方法：找到一个数，对应X要置为1的位，该数的对应位为1，其余位为0，此数与X相或可使X中的某些位 置为1

^  异或运算

两个相应位为“异”（值不同），则该位结果为1，否则为0

0^0=0 0^1=1  1^0=1  1^1=0

例如：51&5     0011 0011 ^ 0000 0101  =  00110110 所以51&5=54

异或运算符的特殊用法

（1）     使特定位翻转，找一个数，对应X要翻转的各位，该数的对应位为1，其余为0，此数与X对应位异或即可

例如：X=10101110,使第四位翻转，用X^0000 1111=1010 0001即可得到

（2）       与0相异或，保留原值

X^00000000=1010 1110

（3）       两个变量交换值的方法

1，借助第三个变量来实现

C=A A=B B=C

2，利用加减法实现两个变量的交换

A=A+B B=A-B  A=A-B

用位异或运算来实现，也是效率最高的一种

原理：利用一个数异或本身等于0和异或运算符合交换律

如：A=A^B  B=A^B A=A^B

~  反运算

对一个二进制进行取反运算，即将0变为1，将1变为0

~1=0     ~0=1

<< 左移运算

将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）

例如：2<<1=4(2的二进制是10，左移1位后为100,100就是4)

若左移时舍弃的高位不包含1，则每左移1位，相当于乘2.

>> 右移运算

将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。操作数每右移一位，相当于该数除以2（左补0 还是1得看被移数是正还是负）

负数以其正值的补码形式表示

原码：一个整数按照绝对值大小转换成的二进制，称为原码

例如00000000 00000000 00000000 00001110是14的原码

反码：将二进制按位取反，所得的新二进制数称为原二进制数的反码

例如 00000000 000000000 00000000 00001110每一位取反得

11111111 11111111 11111111 11110001  这两个互为反码

补码：将反码加1称为补码

11111111 11111111 11111111 11110001+1=1111111111111111 11111111 11110010

 

-14的二进制补码为(1111111111111111 11111111 11110010)

左移两位之后

11111111 11111111 11111111 11001000

=？

分析：只需要该补码的原码对应的正值，然后取相反数

1，  补码减1得到反码（11000111）

2，  补码取反得到原码（即该负数的正值）（00111000）

3，  计算该二进制的值为56

4，  取相反数即为本题答案

JAVA内置的进制转换

十进制转换成十六进制   Integer.toHexString(int i)

十进制转换成八进制     Integer.toOctalString(int i)

十进制转换成二进制     Integer.toBinaryString(int i)

十六进制转换成十进制   Integer.valueOf(“FFFF”,16).toString()

八进制转换成十进制     Integer.valueOf(“376”,8).toString()

二进制装换成十进制     Integer.valueOf(“0101”,2).toString()

Publicclass RadixMain{

 

         Public static void main(String []args)

//十进制转换成其他进制

         System.out.println(Integer.toBinaryString(112))//二进制

System.out.println(Integer.toHexing(112))//十六进制

 

System.out.println(Integer.toOctalg(112))//八进制

//其他进制转换成十进制

         System.out.println(Integer.parseInt(“11001”,2))//二进制

         System.out.println(Integer.parseInt(“272))//八进制

         System.out.println(Integer.parseInt(“A8”,2))//十六进制

}

}

下边是基本数据类型与字节之间的转化

package byteoperator;

/*

 * 数据类型   转化   字节

 * 例如

 * 8143(00000000 00000000 00011111 11001111)(我们都知道int占4个字节，一个字节代表8位)

 * 下面我们来计算

 * 第一个字节：8143 >> 0*8&0xff =(11001111)=207(这是无符号的，如果转成有符号就是-49（207-256）)

 * 第二个字节：8143 >> 1*80fxx =(00011111)=31

 * 第三个字节：8143 >> 2*80fxx =(00000000)=0

 * 第四个字节：8143 >> 3*80fxx =(00000000)=0

 * 我们暂时不用知道这个是怎么运算的，不难看出每一个字节就是该数从右往左的每个字节的二进制（记住这个即可）

 */

 

public classByteOpe {

    /*

     * int 转化为byte[]

     * 补充

     * 以0x开始的数据表示16进制，0xff换成十进制为255。

     *A，B，C，D，E，F这五个字母来分别表示10，11，12，13，14，15。

     *16进制变十进制：f表示15。第n位的权值为16的n次方，由右到左从0位起。

     * 0xff = 15*16^1 + 15*16^0 = 255

     *16进制变二进制再变十进制：

     *0xff = 1111 1111 = 2^8 - 1 = 255

     *

     */

    public static byte[] int2Bytes(int id){

        byte[] arr=new byte[4];

        /*arr[0]=(byte)((int)(id>>0*8)&0xff);//先转换成int型，再转换成byte型

        arr[1]=(byte)((int)(id>>1*8)&0xff);

        arr[2]=(byte)((int)(id>>2*8)&0xff);

        arr[3]=(byte)((int)(id>>3*8)&0xff);*/

        for(int i=0;i<arr.length;i++){

            arr[i]=(byte)((int)(id>>i*8)&0xff);

        }

        return arr;

    }

    /*

     * 转化byte[]为int型

     */

    public static int bytes2int(byte[] arr){

        /*int rs0=(int)((arr[0] & 0xff)<< 0*8);

        intrs1=(int)((arr[1] & 0xff) << 1*8);

        intrs2=(int)((arr[2] & 0xff) << 2*8);

        intrs3=(int)((arr[3] & 0xff) << 3*8);*/

        int result=0;

        for(int i=0;i<arr.length;i++){

            result+=(int)((arr[i] & 0xff)<<i*8);

        }

        return result;

    }

    public static void main(String[] args) {

        byte[] arr=ByteOpe.int2Bytes(8143);

        System.out.println(arr[0]+","+arr[1]+","+arr[2]+","+arr[3]);

        System.out.println(ByteOpe.bytes2int(arr));

        /*

         * 字符串转化为字节

         * 字符串->字节数组

         * String s;

         * byte[] bs=s.getBytes();

         * 字节数组->字符串

         * byte[] bs=new byte[int];

         * String s=new String(bs);

         */

        Stringdescribe= "我每天都练功，我天下无敌。哈哈...";

        byte[] barr=describe.getBytes();//这个函数就将该字符串转化成了字节数组

        Stringdes=new String(barr);

        System.out.println(des);

    }

}

这里只说了两个，其他的进本数据类型转化，不再一一列举，大家可以自己尝试练习一下