遇见go语言的第三天——数组、切片

一、数组

数组初始化

var a2  = [3]int{4,5,6}
	fmt.Println(a2)
	var a3 = [...]int{7,8,9}
	fmt.Println(a3)
	var a4  = [...]int{1:1,0:2,2:3}
	fmt.Println(a4)

独有的遍历结构 -for-range

	//index是数组的下标
	//value是该下标位置的值
	//仅在for循环内部可见的局部变量
	//遍历数组元素时，如果不想使用下标index,可以直接把下标index标为下划线_
	//index和value的名称不是固定的，可自行指定
	for index,value := range a{
	}

实例一：创建一个byte类型的26个元素的数组，分别放置A-Z

func main()  {
	var a [26]byte
	for i := 0;i < 26;i++{
		a[i] = 'A' + byte(i)
	}
	for i :=0;i < 26;i++{
		fmt.Printf("%c  ",a[i])
	}
}

实例二：请求出以一个数组的最大值，并得到对应的下标

var b [10]int
	for i:=0;i<10;i++{
		fmt.Printf("请输入第%d个元素",i+1)
		fmt.Scanln(&b[i])
	}
	maxa := b[0]
	maxindex := 0
	for i:=1;i<len(b);i++{
		if maxa < b[i]{
			maxa = b[i]
			maxindex = i
		}
	}
	fmt.Printf("b[%d]=%d",maxindex,maxa)

实例三：请求出一个数组的和和平均值

var b [10]int
	for i:=0;i<10;i++{
		fmt.Printf("请输入第%d个元素:",i+1)
		fmt.Scanln(&b[i])
	}
	sum := 0
	for i:=0;i<len(b);i++{
		sum = sum + b[i]
	}
	average := float64(sum)/float64(len(b))
	fmt.Printf("sum = %d\n",sum)
	//让平均值保留到小数
	fmt.Printf("average = %v",average)

实例四：随机生成五个数，并将其反转打印

var c [5]int
	rand.Seed(time.Now().UnixNano())
	for i:=0 ;i < len(c) ;i++  {
		c[i] = rand.Intn(100)
	}
	fmt.Println(c)
	temp := 0
	for i:=0; i<(len(c)/2); i++{
		temp = c[i]
		c[i] = c[len(c)-i-1]
		c[len(c)-i-1] = temp
	}
	fmt.Println(c)

二、切片

为什么需要切片？
	例如：当我们需要一个数组用于保存学生的成绩，但是学生的个数时不确定的，就使用切片

• 切片是引用类型，所以咋传递时，遵循引用传递机制
• 切片是一个可以动态变化数组，长度是可以变化的

func main()  {
	var a = [...]int{1,2,3,4,5}
	//定义一个切片
	//slice：切片名
	//a[1:3]:表示slice引用到a这个数组的起始下标为1，最后下标为3（但是不包含3）
	slice := a[1:3]
	fmt.Println(a)
	fmt.Println(slice)

	//定义一个切片（方法二）                                        
	//通过make方式创建切片可以指定切片的大小和容量                           
	//如果没有给切片的各个元素赋值，那么就会使用默认值                           
	//通过make方式创建的切片对应的数组是由make底层维护，对外不可见，只能通过scile去访问各个元素
	var b = make([]float64,5,10)                         
	b[0] = 10                                            
	b[3] = 30                                            
	fmt.Println(b)                                       
                                                     
	//定义一个切片（方法三）                                        
	var c = []string{"1,2,3"}                            
	fmt.Println(c)                                       
}

string和sclice数组

• string 底层是一个byte数组，因此string也可以进行切片处理

str := "hello@halou"     
e := str[6:]             
fmt.Println(e)           

• string是不可变的，也就是说不能通过str[0]=’z‘方式来修改字符串

• 如果需要修改字符串，可以先将string ——> []byte 或者[]rune ——>修改 ——>重写转成string

arr := []byte(str)  
arr[0] = 'z'        
str = string(arr)   
fmt.Println(str)    

• 细节：我们转成[ ]byte后，可以处理英文和数字，但是不能处理中文
• 原因是[ ]byte字节来处理，而一个汉字，是3个字节，因此就会出现乱码
• 解决方法是将string转成[ ]rune即可，因为[ ] rune是按字符处理，兼容汉字

arr := []rune(str)
arr[0] = '北'      
str = string(arr) 
fmt.Println(str)  

实例一：编写一个函数fbn(n int)，要求完成：
1） 可以接收一个n int
2） 能够将斐波那契的数列放到切片中

func fbn(n int)[]uint64{
	//声明一个切片，切片大小n
	fbnslice := make([]uint64,n)
	fbnslice[0] = 1
	fbnslice[1] = 1
	for i := 2;i < n;i++{
		fbnslice[i] = fbnslice[i-2]+ fbnslice[i-1]
	}
	return fbnslice
}
func main()  {
	a := fbn(10)
	fmt.Println(a)
}