数组概念
1、数组：是同一种数据类型的固定长度的序列。
2、数组定义：var a [len]int，比如：var a[5]int，一旦定义，长度不能变
3、长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型
4、数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1
5、访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic
6、数组是值类型，因此改变副本的值，不会改变本身的值
7、数组内的内存地址是连续的
数组初始化
var age0 [5]int = [5]int{1,2,3}
var age1 = [5]int{1,2,3,4,5}
var age2 = […]int{1,2,3,4,5,6}
var str = [5]string{3:”hello world”, 4:”tom”}
数据遍历常用两种方法：
- 方法一
for i := 0; i < len(a); i++ {
}
- 方法二
for index, val := range a {
}
案例一：定义一个a数组，传入函数test的数组是副本，不会改变原a数组的内容。
package main
import "fmt"
func test(arr [5]int) {
arr[0] = 1000
}
func main() {
var a [5]int
test(a)
fmt.Println(a)
}
案例二：定义一个a数组，传入函数test的是a数组的指针，会改变原a数组的内容
package main
import "fmt"
func test3(arr *[5]int) {
(*arr)[0] = 1000
}
func main() {
var a [5]int
test3(&a)
fmt.Println(a)
}
多维数组
package main
import "fmt"
func testArray() {
var a [2][5]int = [...][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}
for row, v := range a {
for col, v1 := range v {
fmt.Printf("(%d,%d)=%d ", row, col, v1)
}
fmt.Println()
}
}
func main() {
testArray()
}
切片概念
1、切片：切片是数组的一个引用，因此切片是引用类型
2、切片的长度可以改变，因此，切片是一个可变的数组
3、切片遍历方式和数组一样，可以用len()求长度
4、cap可以求出slice最大的容量，0 <= len(slice) <= (array)，其中array是slice引用的数组
5、切片的定义：var 变量名 []类型，比如 var str []string var arr []int
切片初始化：var slice []int = arr[start:end]，包含start到end之间的元素，但不包含end
var slice []int = arr[0:end]可以简写为 var slice []int=arr[:end]
var slice []int = arr[start:len(arr)] 可以简写为 var slice[]int = arr[start:]
var slice []int = arr[0, len(arr)] 可以简写为 var slice[]int = arr[:]
如果要切片最后一个元素去掉，可以这么写： slice = slice[:len(slice)-1]
- nil切片和空切片
var nilSlice []int //nil切片
slice:=[]int{} //空切片
它们的长度和容量都是0，但是它们指向底层数组的指针不一样，nil切片意味着指向底层数组的指针为nil，而空切片对应的指针是个地址。
- 切片的内存布局：
- 通过make创建切片语法如下：
var slice []type = make([]type, len)
slice := make([]type, len)
slice := make([]type, len, cap)
func testSliceCap() {
a := make([]int, 5, 10)
a[4] = 100
b := a[2:3]
fmt.Printf("a=%#v, len(a) = %d, cap(a)=%d\n", a, len(a), cap(a))
fmt.Printf("b=%#v, len(b) = %d, cap(b)=%d\n", b, len(b), cap(b))
}
- 用append内置函数操作切片
func testAppend() {
var a []int
a = make([]int, 5)
var b []int = []int{10, 11, 12, 14}
a = append(a, b...)
fmt.Printf("a:%#v\n", a)
}
- 遍历切片
for index, val := range slice {
}
- 切片拷贝copy
func testCopy() {
var a []int = []int{1, 2, 3, 4, 5, 6}
b := make([]int, 10)
copy(b, a)
fmt.Println(b)
}
- string底层就是一个byte的数组，因此，也可以进行切片操作
- string本身是不可变的，因此要改变string中字符，需要如下操作：
字符串转成字符切片，改完后再转成字符串
func testStrSlice() {
var str = "hello world"
var b []byte = []byte(str)
b[0] = 'a'
str1 := string(b)
fmt.Printf("str1:%s, %d\n", str1, len(str))
}
排序和查找操作
排序操作主要都在 sort包中，导入就可以使用
- sort.Ints对整数进行排序， sort.Strings对字符串进行排序, sort.Float64s对浮点数进行排序
func testIntSort() {
var a = [...]int{1, 8, 38, 2, 348, 484}
sort.Ints(a[:])
fmt.Println(a)
}
- sort.SearchInts(a []int, b int) 从数组a中查找b，前提是a必须有序
func testIntSearch() {
var a = [...]int{1, 8, 38, 2, 348, 484}
sort.Ints(a[:])
index := sort.SearchInts(a[:], 348)
fmt.Println(index)
}
- sort.SearchFloats(a []float64, b float64) 从数组a中查找b，前提是a必须有序
- sort.SearchStrings(a []string, b string) 从数组a中查找b，前提是a必须有序