1.解决包级变量的依赖顺序，然后按照包级变量声明出现的顺序依次初始化
2.包中含有多个.go源文件，它们将按照发给编译器的顺序进行初始化
3.init初始化函数,在每个文件中的init初始化函数，在程序开始执行时按照它们声明的顺序被自动调用
4.每个包在解决依赖的前提下，以导入声明的顺序初始化，每个包只会被初始化一次,在main函数执行之前，所有依赖的包都已经完成初始化工作了
5.一个数字中含二进制1bit的个数算法,统计出一个int型数值中比特值为1的比特个数
&是二进制“与”运算，参加运算的两个数的二进制按位进行运算，运算的规律是：
0 & 0=0
0 & 1=0
1 & 0=0
1 & 1=1
练习 2.3： 重写PopCount函数，用一个循环代替单一的表达式。比较两个版本的性能。（11.4节将展示如何系统地比较两个不同实现的性能。）
练习 2.4： 用移位算法重写PopCount函数，每次测试最右边的1bit，然后统计总数。比较和查表算法的性能差异。
练习 2.5： 表达式x&(x-1)用于将x的最低的一个非零的bit位清零。使用这个算法重写PopCount函数，然后比较性能。
package main
import(
"fmt"
)
var pc [256]byte
func init() {
for i := range pc {
pc[i] = pc[i/2] + byte(i&1)
}
}
func main(){
a := PopCount1(80)
fmt.Println(a)
n := PopCountFor(80)
fmt.Println(n)
}
//练习 2.4： 用移位算法重写PopCount函数，每次测试最右边的1bit，然后统计总数。比较和查表算法的性能差异。
//移位算法
func PopCount1(x uint64) int{
num := 0
for i:=0;x!=0;x=x>>1{
if x&1 == 1{
i++
}
num=i
}
return num
}
//练习 2.5： 表达式x&(x-1)用于将x的最低的一个非零的bit位清零。使用这个算法重写PopCount函数，然后比较性能。
//x & (x-1)算法
func PopCount2(x uint64) int{
num := 0
for x!=0{
x = x&(x-1)
num++
}
return num
}
//查表法
func PopCount(x uint64) int {
return int(pc[byte(x>>(0*8))] +
pc[byte(x>>(1*8))] +
pc[byte(x>>(2*8))] +
pc[byte(x>>(3*8))] +
pc[byte(x>>(4*8))] +
pc[byte(x>>(5*8))] +
pc[byte(x>>(6*8))] +
pc[byte(x>>(7*8))])
}
//练习 2.3： 重写PopCount函数，用一个循环代替单一的表达式。比较两个版本的性能。（11.4节将展示如何系统地比较两个不同实现的性能。）
//查表法,使用循环
func PopCountFor(x uint64) int {
var num byte
var i uint64
for i =0;i<8;i++{
num+=pc[byte(x>>(i*uint64(8)))]
}
return int(num)
}
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12554.html