Go语言核心编程---07数组与切片

7.1 数组

7.1.1 数组定义和内存布局

• 数组的定义

var 数组名 [数组大小]数据类型

var a [5]int

赋初值 a[0] = 1 a[1] = 30....

• 数组在内存布局

  • 数组的地址可以通过数组名来获取&intArr

  • 数组的第一个元素的地址，就是数组的首地址，也是数组的地址，即&intArr = &intArr[0]

  • 数组各个元素的地址间隔是依据数组的类型决定，比如int64->8，int32->4

7.1.2 数组的使用

• 访问数组元素：数组名[下标]，注意数组下标从0开始

• 初始化数组：

  • var numArr01 [3]int = [3]int{1,2,3}

  • var numArr02 = [3]int{1,2,3}

  • var numArr03 = [...]int{1,2,3}这里的[…]是规定的写法

  • var numArr04 = [...]int{1:1, 0:2, 2:3}

• 数组的遍历

  • for循环

  • for-range结构遍历：for index, value := range Arr {}，第一个返回值index是数组的下标，第二个value是该下标位置的值，它们都是仅在for循环内部可见的局部变量，名字不固定，如果不想使用index可以把它标为下划线。

• 数组使用的注意事项和细节

  • 数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化。

  • var arr []int这时arr就是一个slice切片。

  • 数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。

  • 数组创建后，如果没有赋值，有默认值（零值）。

  • 使用数组的步骤：声明数组并开辟空间->给数组各个元素赋值->使用数组。

  • 数组的下标是从0开始的。

  • 数组下标必须在指定范围内使用，否则报panic：数组越界。

  • Go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响。

  • 如果想在其它函数中修改原来的数组，可以使用引用传递（指针方式）。

  • 长度是数组类型的一部分，在传递函数参数时，需要考虑数组的长度。如：var arr = [...]int{1,2,3}在传递给函数的时候，接收的形参为：arr [3]int，注意要指定正确的数组长度。

• 实践：将A~Z存在数组中并打印

var myChar [26]byte
for i := 0; i < 26; i++{
   myChar[i] = 'A' + byte(i) //一定要显式转换
   fmt.Printf("%c", myChar[i])
}

---

7.2 切片

7.2.1 切片介绍

• 为什么需要切片？类似于数组，但是长度不固定。

• 切片介绍

  • 切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。

  • 切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度都一样。

  • 切片的长度是可以变化的，因此切片是一个可以动态变化的数组。

  • 切片定义的基本语法：``var 切片名 []类型```

var intArr = [...]int{1,2,3,4,5}
//intArr[1:3]表示slice引用到intArr这个数组，起始下标为1最后的下标为3（不包含）
slice := intArr[1:3]
fmt.Println("切片的元素是：",slice) //切片的元素是： [2 3]
fmt.Println("切片的长度是：",len(slice)) //切片的长度是： 2
fmt.Println("切片的容量是：",cap(slice)) //切片的容量是： 4，切片的容量是可以动态变化的

• 切片在内存中形式

  • 切片是一个引用类型，切片本身有存储的地址，切片第一个元素存储的是被引用数组具体引用的起始地址

  • 切片从底层来说，其实就是一个数据结构

type slice struct {

    ptr *[2] int //指向引用数组被引用的起始地址，如例子中下标为1的元素的存储地址

    len int

    cap int

}

7.2.2 切片的使用

• 方式1：定义一个切片，然后让切片去引用一个已经创建好的数组。

var intArr = [...]int{1,2,3,4,5}
//intArr[1:3]表示slice引用到intArr这个数组，起始下标为1最后的下标为3（不包含）
slice := intArr[1:3]
fmt.Println("切片的元素是：",slice) //切片的元素是： [2 3]
fmt.Println("切片的长度是：",len(slice)) //切片的长度是： 2
fmt.Println("切片的容量是：",cap(slice)) //切片的容量是： 4，切片的容量是可以动态变化的

• 方式2：通过make来创建切片：var 切片名 []type = make([]type, len, [cap])
  参数说明：type数据类型，len大小，cap切片容量（可选），如果分配了cap要求cap≥len。

  • 通过make方式创建切片可以指定切片大小和容量

  • 如果没有给切片的各个元素赋值，那么就会使用默认值（零值）

  • 通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素

var slice []float64 = make([]float64, 5, 10)
slice[1] = 10
slice[2] = 20
fmt.Println(slice) //[0 10 20 0 0]
fmt.Println("slice的大小：",len(slice)) //slice的大小： 5
fmt.Println("slice的容量：",cap(slice)) //slice的容量： 10

• 方式3：定义一个切片，直接指定具体数组，使用原理类似make的方式。

var slice []string = []string{"tom", "jack", "mary"}

• 方式1和方式2的区别：方式1是直接引用数组，这个数组是事先存在的，程序员可见的。方式2是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。

7.2.3 切片的遍历

• for循环常规方式遍历
  for i := 0; i < len(slice); i++ {}
• for-range结构遍历切片
  for i, v := range slice {}

7.2.4 切片使用的注意事项和细节

• 切片初始化：var slice = arr[startIndex:endIndex]
  从arr数组下标为startIndex，取到下标endIndex的元素（不含arr[endIndex]）。
• 切片初始化时仍然不能越界。范围在[0, len(arr)]之间，但是可以动态增长。

var slice = arr[0:end] //可以简写为var slice = arr[:end]
var slice = arr[start:len(arr)] //可以简写为var slice = arr[start:]
var slce = arr[0:len(arr)] //可以简写为var slice = arr[:] 

• cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
• 切片完成定义后，还不能使用，因为本身是空的，需要让其引用到一个数组，或者make一个空间供切片使用。
• 切片可以继续切片。如果对切片中的元素进行修改，原数组也会被修改，因为它们指向的都是同一个空间，切片只是一个引用，没有值拷贝。

var intArr = [...]int{1,2,3,4,5,6}
slice := intArr[1:5]
slice1 := slice[1:3]
fmt.Println(slice) //[2 3 4 5]
fmt.Println(slice1) //[3 4]
slice1[0] = 10
fmt.Println(slice1) //[10 4]
fmt.Println(slice) //[2 10 4 5]
fmt.Println(intArr) //[1 2 10 4 5 6]

• 用append内置函数，可以对切片进行动态追加：slice = append(slice, 10, 20)
  底层原理：append操作本质是对数组扩容。Go底层会创建一个新的数组newArr（大小为扩容后的大小）将slice原来的元素拷贝到新的数组newArr，slice重新引用到newArr，旧的数组就被当做垃圾被清理。
• 切片的拷贝操作：切片使用copy内置函数完成拷贝，copy(slice1, slice2)，将slice2拷贝到slice1，拷贝后的两个切片数据空间是独立的相互不影响。
  **注意：**如果slice1的空间大小比slice2小，那么只会拷贝指定长度的数据到slice1。

var a []int = []int{1,2,3}
var slice = make([]int,1)
copy(slice,a) //slice=[1]

• 切片是引用类型，所以在传递时，遵守引用传递机制，即传入函数时对切片进行修改则原来的切片会一起被修改。

7.2.5 string和slice

• string底层是一个byte数组，因为string也可以进行切片处理。
• string和切片在内存的形式：
  
• string是不可变的，即不能通过str[0]='z'的方式来修改字符串。
• 如果要修改字符串，可以先将string转为[]byte/[]rune然后修改最后重写转成string。

arr := []byte(str) //如果要对中文进行操作转成[]rune
arr[0] = 'z'
str = string(arr)