Go 语言 进制的转换、位运算符的使用

Go 语言 进制的转换、位运算符的使用

1. 二进制：0，1，满 2 进 1；

   在 go 中，不能直接使用 二进制来表示一个整数。

2. 十进制：0-9，满 10 进 1；

3. 八进制：0-7，满 8 进 1。以数字 0 开头表示；

4. 十六进制：0-9 及 A-F，满 16 进 1。以 0x 或 0X 开头表示；

   A-F 不区分大小写

举个栗子：

package main
import (
	"fmt"
)

func main(){
	var i int = 5
	// 二进制输出
	fmt.Printf("i 的二进制是 %b\n", i)

	// 八进制: 0-7 满8进1， 以数字0开头表示
	var j int = 011
	fmt.Println("j=", j)

	// 十六进制: 0-9 及 A-F, 满 16 进 1, 以0X 或 0x开头
	var k int = 0x111
	fmt.Println("k=", k)
}	

// 输出结果
i 的二进制是 101
j= 9
k= 273

一、其他进制转十进制：

1.二进制转十进制：

规则：从最低位开始(右边)，将每个位上的数提取出来，乘以2的(位数-1)次方，然后求和。

• 将 二进制 1011 转成 十进制：

  1011 = 1 * 2(1-1) + 1 * 2(2-1) + 0 * 2(3-1) + 1 * 2(4-1)

  1011 = 1 * 1 + 1 * 2 + 0 + 1 * 8

  1011 = 1 + 2 + 8

  1011 = 11

2.八进制转十进制：

规则：从最低位开始(右边)，将每个位上的数据取出来，乘以8的(位数-1)次方，然后求和。

• 将 八进制 转成 十进制：

  0123 = 3 * 8(1-1) + 2 * 8(2-1) + 1 * 8(3-1) + 0 * 8(4-1)

  0123 = 3 + 16 + 64 + 0

  0123 = 83

3.十六进制转十进制：

规则：从最低位开始(右边)，将每个位上的数据提取出来，乘以16的(位数-1)次方，然后求和。

• 将 0x34A 十六进制 转成 十进制：

  0x34A = 10 * 16(1-1) + 4 * 16(2-1) + 3 * 16(3-1)

  0x34A = 10 * 1 + 4 * 16 + 3 * 16 * 16

  0x34A = 842

二、十进制转其他进制：

1.十进制转二进制：

规则：将 该数不断除以2，直到商为0为止，然后每步得到的余数倒过来，就是对应的二进制。

• 将 56 从十进制转换 二进制：

  56 / 2 = 28 余 0

  28 / 2 = 14 余 0

  14 / 2 = 7 余 0

  7 / 2 = 3 余 1

  3 / 2 = 1 余 1

  剩 1

  最后结果： 111000

2.十进制转八进制：

规则：将该数不断除以8，直到商为0为止，然后每步得到的余数倒过来，就是对应的八进制。

• 将 156 从十进制 转换成 八进制：

  156 / 8 = 19 余 4

  19 / 8 = 2 余 3

  剩 2

  最后结果：0234

3.十进制转十六进制：

规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的十六进制。

• 将 356 从 十进制转换成 十六进制：

  356 / 16 = 22 余 4

  22 / 16 = 1 余 6

  剩 1

  最后结果：0x164

三、二进制转其他进制：

1.二进制转八进制：

规则：将二进制数每三位一组(从低拉开始组合)，转成对应的八进制数。

• 将 二进制 11010101 转成 八进制；

  11 010 101 每三位一组

  101 = 1 * 2(1-1) + 0 + 1 * 2(3-1) = 1 + 0 + 4 = 5

  010 = 0 * 2(1-1) + 1 * 2(2-1) + 0 = 0 + 2 + 0 = 2

  11 = 1 * 2(1-1) + 1 * 2(2-1) = 1 + 2 = 3

  最后八进制为：0325

2.二进制转十六进制：

规则：将二进制数每四位一组(从低位开始组合)，转成对应的十六进制数。

• 将 二进制 11010101 转成 十六进制

  1101 0101 每四位一组

  0101 = 1 * 2(1-1) + 0 + 1 * 2(3-1) + 0 = 1 + 0 + 4 + 0 = 5

  1101 = 1 * 2(101) + 0 + 1 * 2(3-1) + 1 * 2(4-1) = 1 + 0 + 4 + 8 = 13

  最后十六进制为：0xd5

四、其他进制转二进制：

1.八进制转二进制：

规则：将八进制数每1位，转成对应的一个3位的二进制数。

• 将 八进制 0237 转成 二进制；

  0237

  7 / 2 = 3 余 1

  3 / 2 = 1 余 1

  剩 1

  7 对应 一个3位二进制数 111

  3 / 2 = 1 余 1

  剩 1

  3 对应的 一个3位 二进制数 011

  2 / 2 = 1 余 0

  2 对应的一个 3位 二进制数 010

  结果：010 011 111

2.十六进制转二进制：

规则：将十六制数每1位，转成对应的一个4位的二进制数。

• 将 十六进制 0x237 转成 二进制；

  0x237

  7 / 2 = 3 余1

  3 / 2 = 1 余 1

  剩 1

  7 对应 一个4 位 二进制数 0111

  3 / 2 = 1 余 1

  剩 1

  3 对应 一个 4位 二进制数 0011

  2 / 2 = 1 余 1

  剩 0

  2 对应 一个4位 二进制数 0010

  结果： 10 0011 0111

五、位运算符：

运算符	描述
&	按位与运算符。功能是参与运算的两数各对应的二进位相与。运算规则：同时为 1，结果为 1 ，否则为0
|	按位或运算符。功能是参与运算的两数各对应的二进位相或。运算规则：有一个为1，结果为1，否则为0
^	按位异或运算符。功能是参与运算的两数各对应的二进位相异或。运算规则：当二进位不同时，结果为1，否则为0
<<	左移运算符。功能是把<<左边的运算数的各二进位全部左移若干位，高位丢弃，低位补0。左移n位就是乘以2的n次方
>>	右移运算符。功能是把>>右边的运算数的各二进位全部右移若干位，右移n位就是除以2的n次方

1. 原码、反码、补码讲解：

对于有符号而言：

1. 二进制的最高位是符号位：0表示正数，1表示负数：

   1 - - - > [0000 0001] // 正数

   -1 - - - > [1000 0001] // 负数

2. 正数的原码、反码、补码都一样；

3. 负数的反码 = 它的原码符号位不变，其它位取反(0 -> 1, 1 -> 0)；

   1 - - -> 原码 [0000 0001] 反码 [0000 0001] 补码 [0000 0001]

   -1 - - -> 原码 [1000 0001] 反码 [1111 11110] 补码 [1111 1111] // 负数补码 = 反码 + 1

4. 负数的补码 = 它的反码 + 1；

5. 0 的反码，补码都是0；

6. 计算机运算时，都是以补码方式来运算的。

   1 + 1 1 - 1 = 1 + (-1)

2.位运算符、移位运算符：

位运算符：

按位与(&)：两位全为 1，结果为 1， 否则为 0 ；

按位或( | )：两位有一个为 1 ，结果为 1，否则为 0；

按位异或( ^ )：两位一个为 0 ，一个为 1，结果为 1，否则为 0；

package main
import (
	"fmt"
)

func main(){
	// 位运算的演示
	fmt.Println(2&3)
	fmt.Println(2|3)
	fmt.Println(2^3)
	fmt.Println(-2^2)
}	

// 输出结果
2
3
1
-4

2 & 3

2 补码：0000 0010

3 补码：0000 0011

2 & 3 0000 0010 (2的二进制补码，跟3的二进制补码，位数相比，都为1, 才为1)

0000 0010 转换成 十进制 = 2

所以 2 & 3 输出结果 2

2 | 3

2 补码 ：0000 0010

3 补码： 0000 0011

2 | 3 0000 0011 (2的补码，跟3的补码，位数相比，有一个为1，就为1)

0000 0011 转成 十进制 = 3

所以 2 | 3 输出结果 3

2 ^ 3

2 补码：0000 0010

3 补码：0000 0011

2 ^ 3 0000 0001 (2的补码，3的补码，位数相比， 一个为1，一个为0 ，才为1)

0000 0001 转成 十进制 = 1

所以 2 ^ 3 输出结果 1

-2 ^ 2

-2 原码：1000 0010

-2 反码：1111 1101

-2 补码：1111 1110 ( 负数情况下，反码+1 = 补码，别忘了我们是二进制 +1 进一位)

2 补码：0000 0010

-2 ^ 2 1111 1100 (2的补码，3的补码，位数相比，一个为1，一个为0，才为1)

1111 1100 为补码 - - -补码转反码需要减 1- - -> 反码 1111 1011 - - -负数操作开头为1 - - -> 原码 1000 0100

1000 0100 转成 十进制(不包括开头的1, 开头1代表是负数) = -4

移位运算：

右移运算符(>>)：低位溢出，符号位不变，并用符号位补溢出的高位；

左移运算符(<<)：符号位不变，低位补0；

package main
import (
	"fmt"
)

func main(){
	// 移位运算符
	a := 1 >> 2
	fmt.Println("右移位运算符a=",a)

	c := 1 << 2
	fmt.Println("左移位运算符c=", c)
}	

// 输出结果
右移位运算符a= 0
左移位运算符c= 4

a := 1 >> 2

1 的 二进制 ：0000 0001 向 右移动两位 -----> 0000 0000 -----> 结果：0

c := 1<< 2

1 的 二进制：0000 0001 向 左移动两位 -----> 0000 0100 -----> 结果：4