进制转换

什么是进制

进制也就是进位计数制，是人为定义的带进位的计数方法（有不带进位的计数方法，比如原始的结绳计数法，唱票时常用的“正”字计数法，以及类似的tally mark计数）。 对于任何一种进制—-X进制，就表示每一位置上的数运算时都是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

Java针对整数变量提供了4种表现形式

  • 二进制

  • 八进制

  • 十进制

  • 十六进制

为什么会有二进制、八进制、十六进制

有二进制的原因是因为计算机最底层的电子元器件只有两种状态—高电平和低电平(有电和没电）。任何数据在计算机中都是以二进制的形式存在的，二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦!

有八进制、十六进制的原因是因为二进制表示同样的数值太长不方便阅读和记忆，而八进制和十六进制较短，方便阅读和记忆。

ASCII 奥斯卡码值1个字节 八位可以表示256不同个字符

计算机中存储单位的换算

  • 8bit=1byte

  • 1kb=1024byte

  • 1mb=1024kb

  • 1gb=1024mb

  • 1tb=1024gb

什么是bit？

二进制：001 每一位就是bit，二进制只能是0/1两种数字组成，是计算机中一个最小的信号单位，可能是高电平也可能是低电平

什么是byte?

1个bit只能表示两种信号或者两种状态，表示的范围很小！因为咱们英文字母就有26个，两种状态很明显不够表示。所以国际标准化组织就规定把8个bit归为一组数据的最小单元!

不同进制的组成

  • 二进制

    • 有0,1组成。以0b开头(不区分大小写)

  • 八进制

    • 由0,1,2…7组成。以0开头

  • 十进制

    • 由0,1,2….9组成。整数位默认是十进制的

  • 十六进制

    • 由0,1,2….,a,b,c,d,e,f(大小写均可)。以0x开头(不区分大小写)

注意：进制位计算也是从0开始的

  1.     //演示100在各个进制之间的值
  2.     public static void main(String[] args) {
  3.         int a = 0b100;//二进制
  4.         int b = 0100;//八进制
  5.         int c = 100;//十进制
  6.         int d = 0x100;//十六进制
  7.         System.out.println("二进制:"+a+"\t八进制:"+b+"\t十进制:"+c+"\t十六进制:"+d);
  8.         //结果为:二进制:4(2^2)    八进制:64(8^2)    十进制:100(默认)    十六进制:256(16^2)
  9.     }

不同进制数据之间的计算

十进制数据之间的计算

10+10=20

二进制数据之间的计算

0b1101+0b1101010=0b1110111

八进制数据之间的计算

0127+0765=01114

十六进制数据之间的计算

(a=10,b=11,c=12,d=13,e=14,f=15)

0x1ab+0x99a=0xb45

练习

  1. ob1110111-0b1111010=?
  2. 01765-043211=?
  3. 0x1fffa-0x2ffab=?

进制转换

  • 系数：每一个位上的数字，例如157，个位系数为7、十位系数为7、百位系数为1

  • 基数：就是进制数，几进制基数就是几，10进制基数就是10

  • 权：一个数据从右往左数，从0开始，对每一位数据进行编号，那么这个编号就是这个位置上的数字的系数

任意进制到十进制的转换

公式：这个数据的各个位上的系数乘以基数的权次幂相加的和

  1. -- 任意进制转换成十进制
  2. 0b111=1*2^0+1*2^1+1*2^2=1+2+4=7
  3. 0110=0*8^0+1*8^1+1*8^2=0+8+64=72
  4. 0xabc1=1*16^0+12*16^1+11*16^2+10*16^3=1+192+2816+40960=43969

十进制到其他进制的转换

公式：用这个数字除基数取余数，直到商为0，余数反转

Java基础之进制转换和位运算 - 图1

  1. -- 把十机制的100转换为其他进制
  2. -- 十进制转二进制
  3. 100=0b1100100
  4. -- 十进制转八进制
  5. 100=0144
  6. -- 十进制转十六进制
  7. 100=0x64

十进制和二进制之间的快速转换

8421码：8421码是中国大陆的叫法，8421码是BCD码中最常用的一种。在这种编码方式中每一位二进制代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。

BCD码：BCD 码(Binary-Coded Decimal〉亦称二进码十进数或二-十进制代码。用4位二进制数来表示1位十进制数中的0~9这10个数码。是一种二进制的数字编码形式，用二进制编码的十进制代码。

BCD码展示：

二进制: 1 1 1 1 1 1 1 1
十进制: 128 64 32 16 8 4 2 1

二进制和八进制、十六进制如何转换

  • 以十进制为桥梁

  • 二进制到八进制3位组合

  • 二进制到十六进制4位组合

有符号数据表示法

什么是有符号数

所谓有符号数就是数据有正负之分就是有符号数，数据无正负之分就是无符号数。例如：+7、-7就是有符号数

有符号数组成

符号位+数值位(例如：int i=+7)

为什么要有符号数？

因为在计算机中，有符号数有三种表示法：原码、反码和补码。而且所有数据的运算都是采用补码进行的。正数的原码、反码和补码都一样

什么是原码？

就是二进制定点表示法，即最高位为符号位，”0”表示正，”1”表示负，其余为表示数值的大小。

什么是反码？

正数的反码与其原码相同，负数的方法是对其原码逐位取反，但符号位除外。

什么是补码？

补码就是在反码的基础上加1

代码示例

  1. package com.edu.baseAndBitOperations.base;
  3. /**
  4.  * 正数和负数是怎么在计算机中进行出储存的
  5.  *
  6.  * @作者 five-five
  7.  * @创建时间 2021/4/16
  8.  */
  9. public class Demo03 {
  10.     public static void main(String[] args) {
  11.         //+7、-7在计算机中是如何储存的
  12.         //有符号数有两部分组成：1.符号位：最高值表示符号，0为正，1为负   2.数值位
  13.         //int的范围：-2的31次方~2的31次方-1(因为有一位是符号位)
  14. //        int i=7;//+7
  15.         //7:0b0000000000,0000000000,0000000001,11
  16.         int i=0b00000000000000000000000000000111;
  17.         System.out.println(i);
  19.         //int j=-7;//-7
  20.         //0b10000000000000000000000000000111;
  21.         //计算机存储有符号数的时候是按照补码的形式存进去的
  22.         //0b10000000000000000000000000000111;不是二进制的补码，而是二进制的原码
  23.         //计算机有符号数据都是按照补码的形式存进去的
  25.         //正数的原码反码补码都一样,负数的原码反码补码是不一样的
  26.         //什么是原码：就是符号位+数值位
  27.         //什么是反码：除符号位不变，其他位全部1变0,0变1
  28.         //什么是补码：补码就是在反码的基础上加1
  29.         /*
  31.             +7:
  32.                 原码：0b0,00000000,00000000,00000000,00001,11
  33.                 反码：0b0,00000000,00000000,00000000,00001,11
  34.                 补码：0b0,00000000,00000000,00000000,00001,11
  36.             -7:
  37.                 原码：0b1,00000000,00000000,00000000,00001,11
  38.                 反码：0b1,11111111,11111111,11111111,11110,00
  39.                 补码：0b1,11111111,11111111,11111111,11110,01
  40.          */
  41.         int j=0b11111111111111111111111111111001;//-7
  42.         System.out.println(j);
  43.         //计算机在显示给我们看的时候，会把补码转换为原码
  44.         //怎么转：补码-1变成反码，剩下的除符号位不变，其余的0变1,1变0
  45.     }
  46. }

位运算(位指的是二进制位或者是bit位)

计算机中所有的订算到计算机底层中都会变成位运算(就是二进制位的运算)。位运算可以提高程序的效率!而且以后如果我们研究JDK或者某个框架的原码，会发现很多地方都用到了位运算!

位运算的种类

  • **&**：按位与，规则：两个同为1时才为1

  • **|**：按位或，规则：只要上下有一方为1的时候，就等于1

  • **^**：按位异或，规则：两个中不一样的时候才为1，如果一样就为0

  • **~**：按位取反，规则：1变0,0变1

  • **<<**：左移，规则：让操作数乘以2的n次幂，n就是移动的位移

  • **>>**：右移，规则：让操作数除以2的n次幂，n就是移动的位移

  • **>>>**：无符号右移，规则：操作数除以2的n次幂，用0补全空位

  • 无符号右移**>>>**和右移**>>**的区别是：

    • **>>**右移操作之后左边会有空位置出来且空位置用该操作数的符号位置的数补全

    • **>>>**无符号右移之后左边会有空位置出来且空位置用0补全

注意：进行位运算的时候，所有的操作数全部都是二进制，并且是补码!!!

代码示例

&、|、、按位取反~）

  1. package com.edu.baseAndBitOperations.base;
  3. /**
  4.  * 位运算符的操作和理解,（按位与&、按位或|、按位异或^、按位取反~）
  5.  * 注意：进行位运算的时候，所有的操作数全部都是二进制，并且是补码!!!
  6.  *
  7.  * @作者 five-five
  8.  * @创建时间 2021/4/16
  9.  */
  10. public class Demo04 {
  11.     /*
  12.         &：按位与，只有上下都为1的时候，才等于1
  13.         |：按位或，只要上下有一方为1的时候，就等于1
  14.         ^：按位异或，两个中不一样的时候才为1，如果一样就为0
  15.         ~：按位取反，1变0,0变1
  16.         <<：左移，让操作数乘以2的n次幂，n就是移动的位移
  17.         >>：右移，让操作数除以2的n次幂，n就是移动的位移
  18.         >>>：无符号右移，操作数除以2的n次幂，用0补全空位
  20.      */
  21.     public static void main(String[] args) {
  22.         //注意：在进行位运算时时候要把数据转换成二进制位！并且全部都是二进制的补码形式。
  23.         //按位与:&，只有上下都为1的时候，才等于1
  24.         //3&4的结果
  25.         //3:0b0000000000,0000000000,0000000000,11
  26.         //4:0b0000000000,0000000000,0000000001,00
  27.         //3&4:0b0000000000,0000000000,0000000000,00
  28.         System.out.println(3 & 4);//0
  30.         //注意：在进行位运算时时候要把数据转换成二进制位！并且全部都是二进制的补码形式。
  31.         //按位或:|，只要上下有一方为1的时候，就等于1
  32.         //3|4的结果
  33.         //3:0b0000000000,0000000000,0000000000,11
  34.         //4:0b0000000000,0000000000,0000000001,00
  35.         //3|4:0b0000000000,0000000000,0000000001,11
  36.         System.out.println(3 | 4);//7
  38.         //注意：在进行位运算时时候要把数据转换成二进制位！并且全部都是二进制的补码形式。
  39.         //按位异或:^，两个中不一样的时候才为1，如果一样就为0
  40.         //3^4的结果
  41.         //3:0b0000000000,0000000000,0000000000,11
  42.         //4:0b0000000000,0000000000,0000000001,00
  43.         //3^4:0b0000000000,0000000000,0000000001,11
  44.         System.out.println(3 ^ 4);//7
  46.         //注意：在进行位运算时时候要把数据转换成二进制位！并且全部都是二进制的补码形式。
  47.         //按位取反:~，1变0,0变1
  48.         //~4的结果
  49.         //4:0b0000000000,0000000000,0000000001,00
  50.         //~4:0b11111111111111111111111111111110,11（相当于补码）
  51.         //反码:0b11111111111111111111111111111110,10（补码-1=反码）
  52.         //源码:0b10000000000000000000000000000001,01（反码取反=原码）
  53.         System.out.println(~4);//-5
  54.     }
  55. }

按位异或的常见应用

  1. package com.edu.baseAndBitOperations.base;
  3. /**
  4.  * ^：按位异或，两个中不一样的时候才为1，如果一样就为0
  5.  * 按位异或^的常见应用：一个数据对相同的数据异或两次其值不变
  6.  *
  7.  * @作者 five-five
  8.  * @创建时间 2021/4/16
  9.  */
  10. public class Demo05 {
  11.     public static void main(String[] args) {
  12.         /*
  13.             数据a
  14.             数据b
  15.             a两次异或b 结果还是a
  16.             a^b^b=a
  17.          */
  18.         int a = 2;
  19.         int b = 3;
  20.         //2:0b00000000,00000000,00000010
  21.         //3:0b00000000,00000000,00000011
  22.     //a=2^3:0b00000000,00000000,00000001
  23.       //a^3:0b00000000,00000000,00000010
  24.         int temp = a ^ b;
  25.         temp ^= b;
  26.         System.out.println(a ^ b ^ b);
  27.         System.out.println(temp);
  28.     }
  29. }

<<、>>、>>>位运算符的操作和理解,（左移<<、右移>>、无符号右移<<<）

  1. package com.edu.baseAndBitOperations.base;
  3. /**
  4.  * 位运算符的操作和理解,（左移<<、右移>>、无符号右移<<<）
  5.  * 注意：进行位运算的时候，所有的操作数全部都是二进制，并且是补码!!!
  6.  *
  7.  * @作者 five-five
  8.  * @创建时间 2021/4/16
  9.  */
  10. public class Demo06 {
  11.     /*
  12.        &：按位与，只有上下都为1的时候，才等于1
  13.        |：按位或，只要上下有一方为1的时候，就等于1
  14.        ^：按位异或，两个中不一样的时候才为1，如果一样就为0
  15.        ~：按位取反，1变0,0变1
  16.        <<：左移，让操作数乘以2的n次幂，n就是移动的位移
  17.        >>：右移，让操作数除以2的n次幂，n就是移动的位移
  18.        >>>：无符号右移，操作数除以2的n次幂，
  19.        无符号右移和右移的区别是：
  20.             右移操作之后左边会有空位置出来且空位置用该操作数的符号位置的数补全
  21.             无符号右移之后左边会有空位置出来且空位置用0补全
  22.        格式：操作数<<往左移动的位数
  23.             操作数>>往右移动的位数
  24.             操作数>>>往右移动的位数
  25.     */
  26.     public static void main(String[] args) {
  27.         //左移 <<
  28.         int i = 3;
  29.         //3:0b00000000,00000000,00000000,00000011
  30.         //3<<2:0b000000,00000000,00000000,0000001100(往左边移动两位，左边的两位就被挤掉了，右边就空出两位用0补全)
  31.         System.out.println(i << 2);//3*2^2
  33.         //右移 >>
  34.         int j = 32;
  35.         //32:0b00000000,00000000,00000000,00100000
  36.         //32>>2:0b00000000,00000000,00000000,00001000(往右边移动两位，左边就空出两位，右边的两位就被挤掉了，左边空出的位置用符号位的值填充)
  37.         System.out.println(j >> 2);//32/(2^2)
  39.         //-32:0b10000000,00000000,00000000,00100000(原码)
  40.         //-32:0b11111111,11111111,11111111,11011111(反码)
  41.         //-32:0b11111111,11111111,11111111,11100000(补码)
  42.         //-32>>2:0b11111111,11111111,11111111,11100000
  43.         //(往右边移动两位，左边就空出两位，右边的两位就被挤掉了，左边空出的位置用符号位的值填充)
  44.         //-32>>2:0b1111111111,11111111,11111111,111000(补码)
  45.         //-32>>2:0b1111111111,11111111,11111111,110111(反码)
  46.         //-32>>2:0b1000000000,00000000,00000000,001000(原码)
  47.         System.out.println(-j >> 2);//-32/(2^2)
  48.         System.out.println(0b11111111111111111111111111111000);//-32/(2^2)
  50.         //无符号右移 >>>
  51.         int k = 32;
  52.         //32:0b00000000,00000000,00000000,00100000
  53.         //32>>>2:0b00000000,00000000,00000000,00001000(往右边移动两位，左边就空出两位，右边的两位就被挤掉了，左边空出的位置用0填充)
  54.         System.out.println(k >>> 2);//32/(2^2)
  55.         //-32:0b10000000,00000000,00000000,00100000(原码)
  56.         //-32:0b11111111,11111111,11111111,11011111(反码)
  57.         //-32:0b11111111,11111111,11111111,11100000(补码)
  58.         //32>>>2:0b0011111111,11111111,11111111,111000(往右边移动两位，左边就空出两位，右边的两位就被挤掉了，左边空出的位置用0填充)
  59.         System.out.println(-k >>> 2);
  60.         System.out.println(0b00111111111111111111111111111000);
  61.     }
  62. }