GoLang数组切片

1. 数组
1.1 如何定义数组
同java数组一样，数组是一组内存连续且类型相同的数据组成

//不初始化初始值默认为0
var arr1 = [5]int{}
var arr2 = [5]int{1,2,3,4,5}
//声明数组下标3的值为10
var arr3 := [3:10]
arr4 := []int{1,2,3,4,5}
//操作数据
for i := 0; i < len(arr1); i++ {
		arr1[i] = i * 10
	}

for index, value := range arr1 {
	fmt.Printf("index: %d,value:%d\n", index, value)
}

//指定多维数组
arr5 := [5][5]int{
		{1,2,3,4,5},
		{6,7,8,9,10}
	}

　　

1.2 数组作为函数参数
在go语言中传递数组时会对其进行拷贝，如果数组非常大，这是会消耗大量内存，我们可以使用一下两种方式代替：

传递数组的指针
传递切片
1.2.1 指针数组
指针数组就是指针类型的数组，一个数组里面装的全是指针，在go中数组默认都是值传递的，所以会导致我们修改函数中传递过来的数组对原来的数组不会产生影响。

 	func main() {
   		var a [5]int
   		var aPtr *[5]int
   		aPtr = &a
   		//这样简短定义也可以aPtr := &a
   		fmt.Println(aPtr)
   		test(aPtr)
   		fmt.Println(aPtr)
   }

func test(aPtr *[5]int) {
   aPtr[1] = 5
   fmt.Println(aPtr)
}

1.2.2 数组指针
指向数组的指针

 	func main() {
   		var a [5]int
   		var aPtr *[5]int
   		aPtr = &a
   		//这样简短定义也可以aPtr := &a
   		fmt.Println(aPtr)
   		test(aPtr)
   		fmt.Println(aPtr)
   }

func test(aPtr *[5]int) {
   aPtr[1] = 5
   fmt.Println(aPtr)
}

　　

虽然main和test函数中的aPtr是不同的指针，但是他们都指向同一块数组的内存空间，所以无论在main函数还是在test函数中对数组的操作都会直接改变数组。

2. 切片
因为数组是固定长度的，所以在一些场合下就显得不够灵活，所以go语言提供了一种更为便捷的数据类型叫做切片。切片操作与数组类似，但是它的长度是不固定的，可以追加元素，如果以达到当前切片容量的上限会再自动扩容。
对于任何一个切片来说，其都有一个底层数组与之对应，我们可以将切片看作是一个窗口，透过这个窗口可以看到底层数组的一部分元素

2.1 定义切片

//数组不指定长度
	var s1 = []int{}
	var s2 = []int{1,2,3}
	//长度为5的空切片
	var s3 = make([]int,5)
	//长度为5 容量为10的切片
	var s4 = make([]int,5,10)
   //获取切片长度
   len(s1)
   //获取切片容量
   cap(s2)

//切片
   arr := [5]int{1, 2, 3, 4, 5}
   s := []int{6, 7, 8, 9, 10}

   s1 := arr[2:4] //3,4 包左不包右
   s2 := arr[:3]//1,2,3
   s3 := arr[2:]//3,4,5
   s4 := s[1:3]//7,8 包左不包右

//扩充
   a := []int{1, 2, 3}
   b := a[1:3]
   b = append(b, 4)
   b = append(b, 5)

//拼接
   a := []int{1, 2, 3}
   b := a[1:3]
   a = append(a, b...)

//复制
func main() {
   a := []int{1, 2, 3}
   b := make([]int, 3)
   copy(b, a)
   fmt.Println(a)
   fmt.Println(b)
}