编码集

UTF-8 ：万国码。一个字节，中文占三个字节

GBK : 国标编码（国家标准），英文占1字节，中文占 2字节。

ISO8859-1 ：欧洲字符集，网络传输用的是ISO8859-1，不支持中文

N进制：逢N进一

二进制(Binary)：逢二进一

数字： 0 1
权： 1 2 4 8 16 32 64 128

十进制：逢十进一

数字：0 1 2 3 4 5 6 7 8 9
权： … 万千百十个

十六进制：逢十六进一

数字：0-9 ABCDEF
二进制数直接书写繁琐麻烦，JDK开始提供了使用0b前缀。书写二进制的直接量时可以使用"_"进行分割。

对于 N进制数，整数部分第 i位的位权为Ni-1，而小数部分第j位的位权为N-j。

十进制转二进制方法（toBinaryString()）

将10进制数转换为对应的2进制数，输出时会自动省略高位的0.

包装类.toBinaryString()方法；

除二取余法
也可以使用2的n次方表示，

十进制转十六进制（toHexString()）

十六进制：逢十六进一
0-9直接使用数字表示，10-15使用a-f字母表示
十六进制可以用来缩写二进制（十六进制与二进制的转换），十六进制使用0X开头直接书写
从最低位开始。
0 1 2 3 4 5 6 7 8 9 A B C D E F
0b11110001_10101100_11010011_10001101
每四位转换为一位十六进制
即： F 1 A C D 3 8 D

public class Test2_Binary {
    public static void main(String[] args) {
        /*
        * 二进制数直接书写繁琐麻烦，JDK开始提供了使用0b前缀。书写二进制的直接量时可以使用"_"进行分割。
        * */
        //如果二进制过长，可以用分隔符分割，前提是要有0b修饰前缀表示是二进制
        int a = 0b110010_101010;
        /*
        十六进制：逢十六进一
        0-9直接使用数字表示，10-15使用a-f字母表示
        * 十六进制可以用来缩写二进制（十六进制与二进制的转换），十六进制使用0X开头直接书写
        * 从最低位开始。
        * 0 1 2 3 4 5 6 7 8 9 A B C D E F

        0b11110001_10101100_11010011_10001101
        每四位转换为一位十六进制
        即：  F 1 A C D 3 8 D
        * */
        int b = 0xf1acd38d;
        System.out.println(b);
        System.out.println(Integer.toBinaryString(b));
        //Intege.toHexString() 将10进制数转换为16进制字符串
        System.out.println(Integer.toHexString(b));
    }

十进制转八进制（toOctalString）

源代码中写10进制数，在编译时都转换为二进制数，在程序运行期间，变量的值是二进制,当程序输出一个数字的时候，又将2进制转换为10进制字符串输出

public class Test1_Binary {
    public static void main(String[] args) {
        /*
        * 源代码中写10进制数，在编译时都转换为二进制数，
        * 在程序运行期间，变量的值是二进制
        * 当程序输出一个数字的时候，又将2进制转换为10进制字符串输出
        * */
        int a = 50;// 50 -> 110010
        System.out.println(a);//110010 -> "50
        /*
        * Integer.toBinaryString();
        * 将10进制数转换为对应的2进制数，输出时会自动省略高位的0.
        * */
        System.out.println(Integer.toBinaryString(a));//50 - >110010
        /*
        * 00000000 00000000 00000000 00000001 = 1
        * 00000000 00000000 00000000 00000010 = 2
        * 00000000 00000000 00000000 00000011 = 2 + 1
        * 00000000 00000000 00000000 00000100 = 4
        * 00000000 00000000 00000000 00000101 = 5 + 1
        * 00000000 00000000 00000000 00000110 = 4 + 2
        * 00000000 00000000 00000000 00000111 = 4 + 3
        * ……
        * 00000000 00000000 00000000 00110110 = 32 + 16 + 4 + 2 = 54
        * */
        // 练习：输出0-200 之间的2进制数，随机抽取10个，手工计算对应的10进制数，自行检验结果
        for (int i = 0; i < 200; i++){
            System.out.println(Integer.toBinaryString(i));//计算1 - 200之间的2进制。
        }
    }
}

二进制运算

二进制运算： 与&（按位与），或 | (按位或)，异或^(相同为0，不同为1)
计算步骤：
1.先将操作数转换为二进制数，十六进制数每一个数字用四位二进制数表示。八进制每一位数用三位二进制数表示。

public class Test3_Binary {
    public static void main(String[] args) {
        /*
        * & 与运算 规律：有0 则0
        * 0 & 0 = 0
        * 0 & 1 = 0
        * 1 & 0 = 0
        * 1 & 1 = 1
        * 运算时将两个2进制数对齐位置，对应的位进行与运算
        * m =       01100011 11001001 10101111 11010010
        * n =       00000000 00000000 00000000 11111111
        * k = m & n 00000000 00000000 00000000 11010010
        * k中的数据是m中的后8位，可以看做是将m进行拆分，最后的8位
        * 数（1个字节）存储到k中。n数称为掩码，是拆分的依据，
        * 如果从低位到高位有8 个1，就拆分出8位数。上述计算称为掩码计算
        * */
        int m = 0b01100011_11001001_10101111_11010010;
        int n = 0b00000000_00000000_00000000_11111111;
        int k = m & n;
        System.out.println(Integer.toBinaryString(k));

        /*
        * | 或运算，规律：有1 则1
        *  0 | 0 = 0
        *  0 | 1 = 1
        *  1 | 0 = 1
        *  1 | 1 = 1
        * m =        01100011 11001001 10101111 11010010
         * n =       00000000 00000000 01011101 00000000
         * k = m | n 01100011 11001001 11111111 11010010
        * */
        int m1 = 0b01100011_11001001_10101111_11010010;
        int n1 = 0b00000000_00000000_01011101_11111111;
        int k1 = m1 | n1;
        System.out.println(Integer.toBinaryString(k1));

        /*
        * 异或运算规律：相同则为0，不同则为1
        * 0 ^ 0 = 0
        * 0 ^ 1 = 1
        * 1 ^ 0 = 1
        * 1 ^ 1 = 0
        *
        * m =        01100011 11001001 10101111 11010010
        * n =        00000000 00000000 01011101 00000000
        * k = m ^ n  01100011 11001001 11110010 11010010
        * */
        k = m ^ n;
        System.out.println(Integer.toBinaryString(k));
    }
}

补码

补码：计算机处理有符号数（正负数）的一阵底层编码方式

其设计思路是将固定位数的2进制数字，分一半作为负数编码。
高位为0的是正数，高位为1 的是负数，
最高位称为符号位，可以快速分别正负数

正整数：原码 = 补码 = 反码
负整数：
原码：先求该数绝对值的二进制表示，然后最高位符号位变为1
反码：符号位不变，其余按位取反
补码：符号位不变，原码从后往前数，在遇到第一个1之前均保持不变，第一个1之后按位取反。
或者反码+1.

二进制运算之取反

~ 取反规律： 1 变 0,0 变 1
在补码中，一个数的相反数等于这个数取反+1，称为互补对称现象
归纳公式： -n = ~n+1
-5 ----> 5
n = 11111111 11111111 11111111 11111011 = -1 -4 =-5
~n = 00000000 00000000 00000000 00000100 = 4
~n+1 =00000000 00000000 00000000 00000101 = 4 + 1 = 5

二进制运算之移位运算

>>> 逻辑右移（无符号右移）：无论不管正负标志位为0还是1，将该数的二进制码整体右移，左边部分总是以0填充，右边部分舍弃。
计算规则：将一个二进制数整体向右移动，地位自动溢出，高位补0
例：
n = 01100110 11010011 01101010 11100010
m = n >>> 1 00110011 011010011 01101010 1110001
m = n >>> 2 00011001 10110100 11011010 10111000
m = n >>> 8 00000000 0001100110 11010011 01101010

>> 数学右移（有符号右移）：该数对应的二进制码整体右移，左边的用原有标志位补充，右边超出的部分舍弃。

正数：将数位整体向右移动，低位溢出，高位补0
负数：将数位整体向右移动，低位溢出，高位补1
移动后数字的正负属性不变，即符号位不变，结果是数学上除2，向小方向取整
n = 11111111 11111111 11111111 11001110 = -1 -1
m = n >> 1 11111111 11111111 11111111 1100111 = -1
k = n >> 2 11111111 11111111 11111111 110011

<<左移
<< 左移位运算
将一个2进制数整体向左移动，移动后高位溢出，低位补0