第26章 java进制操作

java进制操作

1.二进制

二进制只有0和1，逢二进一
二进制多用在计算机中，来自计算机硬件的开关闭合

2.位运算

分别讲解：

2.1.按位与 &

两位全为1，结果才为1
0&0=0；1&0=0；1&1=1；
例如：51&5=1

0011 0011 & 0000 0101 = 0000 0001

位运算的特殊用法：
1.清零。如果想将一个单元清零，可使其全部二进制为0，只要与一个各位都为0的数值相与，结果就为零
2.取一个数中的指定位。方法是：找一个数，对应X要取的位，该数的对应位为1,其余位为0，此数与X进行“与运算”可以得到X中的指定位
例如：

设X=1010110，取X的低4位
X&0000 1111= 0000 1100;

2.2.按位或 |

只要有一个数为1，结果就为1
0|0=0; 0|1=1; 1|1=1;
例如：

51 | 5 = 55
0011 0011 | 0000 0101 = 0011 0111

或运算的特殊用法：
常用来对一个数据的某些位置1
使用发放是：找到一个数，对应X要置1的位，该数的对应位为1，其余位为0.此数与X相与可使X中的某些位置1
例如：

将X=1010 0000的低4位置为1
X | 0000 1111 = 1010 1111

2.3.亦或运算 ^

两个相应位为“异”（值不同），则该位结果为1，否则为0
0^0=0; 0^1=1; 1^1=0;
例如：

51^5=54
0011 0011 ^ 0000 0101 = 0011 0110

亦或运算的特殊用途
1.使特定位翻转，找一个数，对应X要翻转的各位，该数的对应位为1，其余位为0，此数与X对应位亦或即可
2.与0相异，保留原值

2.4.取反运算 ～

对一个二进制数按位取反，即将0变1,1变0
~1=0； ～0=1；

2.5.左移运算 <<

将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）
2<<1=4
若左移使舍弃的高位不包含1，则每左移一位，就相当于该数乘以2

2.6.右移运算 >>

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

2.7.右移运算 >>

各个位向右移，指定的位数。右移后左边空出的位数用0来填充，移出右边的位被丢弃

3.JDK内置的进制转换

/**
 * 测试JDK中的进制转换
 */
public class TestRadix {
    public static void main(String[] args) {
        /**
         * 十进制转为其他进制
         * 转换的结果是无符号的
         */
        //十进制转二进制
        System.out.println(Integer.toBinaryString(112));//1110000
        //十进制转八进制
        System.out.println(Integer.toHexString(112));//70
        //十进制转十六进制
        System.out.println(Integer.toOctalString(112));//160

        /**
         * 其他进制转化为十进制
         * parseInt接收的是有符号正数作为值传进去，结果也是有符号的
         */
        //
        System.out.println(Integer.parseInt("1110000", 2));
        System.out.println(Integer.parseInt("70"));
        System.out.println(Integer.parseInt("160", 16));
    }

}

4.java中的进制

在平时开发中“进制转换”和“位操作”用的不多，因为java处理的是高层
但是在跨平台中用的较多，如：文件读写和数据通信

4.1.java中的数据类型

基本数据类型只有一下4中：
1.int类型：byte(8bit,1字节)，short(16,2字节),int（32bit，3字节），long（64bit，8字节）
2.float类型：单精度（32bit），双精度（64bit）
3.boolean类型：true,false
4.char类型：unicode字符，16为

以上对应的类型：Integer, Float, Bollean, Character, Double, Short, Byte, Long

4.2.数据类型和字符类型转化为字节

示例代码：

/**
 * 数据类型转化为字节
 */
public class Convert {
    /**
     * int转化为byte[]
     * @param id 接收一个int
     * @return 返回数组
     */
    public static byte[] int2Byets(int id){
        byte[] arr = new byte[4];
//        arr[0] = (byte)((int)(id>>0*8)&0xff);
//        arr[1] = (byte)((int)(id>>1*8)&0xff);
//        arr[2] = (byte)((int)(id>>2*8)&0xff);
//        arr[3] = (byte)((int)(id>>3*8)&0xff);
//        return arr;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (byte)((int)(id>>i*8)&0xff);
        }
        return  arr;
    }

    /**
     * byte转化为int
     * @param arr
     * @return
     */
    public static int byte2Int(byte[] arr){
//        int rs0 = (int)((arr[0]&0xff)<<0*8);
//        int rs1 = (int)((arr[1]&0xff)<<1*8);
//        int rs2 = (int)((arr[2]&0xff)<<2*8);
//        int rs3 = (int)((arr[3]&0xff)<<3*8);
//        return rs0+rs1+rs2+rs3;
        int result = 0;
        for (int i = 0; i < arr.length; i++) {
            result += (int)((arr[i]&0xff)<<i*8);
        }
        return result;
    }


    /**
     * long转化为byte[]
     * @param id 接收一个int
     * @return 返回数组
     */
    public static byte[] long2Byets(int id){
        byte[] arr = new byte[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (byte)((long)(id>>i*8)&0xff);
        }
        return  arr;
    }


    /**
     * byte转化为long
     * @param arr
     * @return
     */
    public static int byte2long(byte[] arr){
//        int rs0 = (int)((arr[0]&0xff)<<0*8);
//        int rs1 = (int)((arr[1]&0xff)<<1*8);
//        int rs2 = (int)((arr[2]&0xff)<<2*8);
//        int rs3 = (int)((arr[3]&0xff)<<3*8);
//        return rs0+rs1+rs2+rs3;
        int result = 0;
        for (int i = 0; i < arr.length; i++) {
            result += (long)((arr[i]&0xff)<<i*8);
        }
        return result;
    }

    public static void main(String[] args) {
        //测试int转化为byte
        byte[] arr = Convert.int2Byets(8143);
        System.out.println(arr[0]+","+arr[1]+","+arr[2]+","+arr[3]);//-49,31,0,0

        //测试byte转化为int
        System.out.println(Convert.byte2Int(arr));//8143

        //测试long转化为byte
        //注意：long型和int就是在字节不同
        byte[] arr1 = Convert.long2Byets(4719857);
        System.out.println(arr1[0]+","+arr1[1]+","+arr1[2]+","+arr1[3]);//-15,4,72,0

        
        //字符串与字节数组
        String dec = "我每天都写代码，我就会很厉害……";
        //字符转化成字节
        byte[] barr = dec.getBytes();
        //字节转化为字符
        String describle = new String(barr);
        System.out.println(describle);
    }
}