万丈高楼平地起-数组和切片

一、数组

1. 数组的特点：数组一旦声明后，其元素类型和长度就不在变化，如果要存储更多的值，只能创建新的数组，让后把原来的数组复制过去
2. golang 数组在函数调用是值传递，这个和其他语言有区别
3. 数组的声明方式
4. 数组代码展示

   package main
   
   import "fmt"
   
   //数组的声明
   func main() {
   	//指定数组的类型 int  指定数组长度5
   	var myArray1 [5]int
   	//由于声明了数组myArray1、但是没初始化，这是时候数组里面对于的是元素类型的零值
   	for _, v := range myArray1 {
   		fmt.Println(v)
   	}
   	//重新赋值
   	myArray1 = [5]int{1, 2, 3, 4, 5}
   	for _, v := range myArray1 {
   		fmt.Println(v)
   	}
   	//定义并初始化 一个长度为10的数组，由于后五没有赋值所有都是零值
   	myArray2 := [10]int{1, 2, 3, 4, 5}
   	for _, v := range myArray2 {
   		fmt.Println(v)
   	}
   
   	//自动推导数组长度
   	fmt.Println("自动推导数组长度--------------")
   	myArray3 := [...]int{1, 2, 3}
   	for _, v := range myArray3 {
   		fmt.Println(v)
   	}
   
   	//多维数组
   	fmt.Println("多维数组--------------")
   	dArray1 := [...][3]int{{1, 2, 3}, {3, 5}}
   	for _, v := range dArray1 {
   		for _, item := range v {
   			fmt.Println(item)
   		}
   	}
   
   }
   

二、切片

1. 切片是基于数组的
2. 切片是一个很小的对象，它对底层的数组(内部是通过数组保存数据的)进行了抽象，并提供相关的操作方法。切片是一个有三个字段的数据结构，这些数据结构包含 Golang 需要操作底层数组的元数据
   
3. 切片的声明

   package main
   
   import "fmt"
   
   func main() {
   
   	//声明要个长度，和容量都是1的切片s1
   	s1 := make([]int, 1)
   	//切片元素赋值
   	s1[0] = 10
   	fmt.Println("s1[0]= ", s1[0])
   	fmt.Println("s1 length= ", len(s1), "s1 cap= ", cap(s1))
   
   	//按需增加切片的容量。Golang 内置的 append() 函数会处理增加长度时的所有操作细节
   	s1 = append(s1, 10)
   	fmt.Println("s1 length= ", len(s1), "s1 cap= ", cap(s1))
   
   	//声明要个长度3、容量是5的切片
   	s2 := make([]int, 3, 5)
   	fmt.Println("s2 length= ", len(s2), "s2 cap= ", cap(s2))
   
   	//声明一个长度和容量都是4的切片
   	s3 := []int{10, 20, 30, 40}
   	fmt.Println("s3 length= ", len(s3), "s3 cap= ", cap(s3))
   
   	//切片声明切片
   	s5 := make([]int, 10)
   	s5[0] = 0
   	s5[1] = 1
   	s5[2] = 2
   	s5[3] = 3
   	s5[4] = 4
   	fmt.Println("s5 length= ", len(s5), "s5 cap= ", cap(s5))
   
   	//这里注意下cap()的计算，是从切片开始指针所指向的数组下标到数组结尾的长度
   	s6 := s5[:3]
   	fmt.Println("s6 length= ", len(s6), "s6 cap= ", cap(s6)) //cap(s6)=10 s6切片指针指向了数组最小下标0
   
   	s7 := s5[2:4]
   	fmt.Println("s7 length= ", len(s7), "s7 cap= ", cap(s7)) //cap(s7)=8 s7切片指针指向了数组下标2 实际底层数组长度是10
   
   	//定义一个nil 切片
   	var s8 []int
   	fmt.Println("s8 is nil= ", (s8 == nil), "s8 length= ", len(s8), "cap= ", cap(s8))
   
   	//切片Copy
   	s9 := []int{10, 20, 30}
   	s10 := make([]int, 5)
   	count := copy(s10, s9) //copy(目标，源)
   	fmt.Println(count)
   	fmt.Println(s10)
   
   }
   

4. 切片在函数调用时候 是copy的切片对象本身，即切片指针 长度 容量。而底层的数组是不会拷贝。故而有很好的效率