数组：同一种数据类型的固定长度的序列
数组定义：var a [len]int
长度是数组类型的一部分
数组的数据类型为值类型
数组可以用new来创建，返回的是一个指向数组的指针
数组可以通过下标进行访问，下标是从0开始，最后一个元素的下标是len-1
访问越界，如果下标在数组合法的范围之外，则触发访问越界，会panic
数组的初始化
1、var a [5]int = [5]int{1,2,3,4,5}
2、var b = [5]int{1,2,3,4,5}
3、var c = [...]int{1,2,3,4,5}
4、var str = [5]string{2 : "tom", 3 : "cat"}
package main
import(
"fmt"
)
func main(){
var a [10]int
b := new([12]int)
(*b)[0] = 12
fmt.Println(a)
fmt.Println(b)
fmt.Printf("%p",b)
}
遍历数组
package main
import(
"fmt"
)
func main(){
a :=[...]int{2,3,4,6}
fmt.Println(a)
for i := 0 ; i<len(a);i++{
fmt.Println(a[i])
}
for index , val := range a {
fmt.Printf("a[%d]=%d\n",index,val)
}
}
数组是值类型，改变副本的值，不会改变本身的值
package main
import(
"fmt"
)
func main(){
var arry1 [5]int
arry2 := arry1
arry2[0]=10
fmt.Println(arry1)
fmt.Println(arry2)
}
输出：
[0 0 0 0 0]
[10 0 0 0 0]
修改数组的值，传地址，通过指针的方式进行修改
package main
import "fmt"
func modify(arry *[5]int){
(*arry)[0]=100
return
}
func main(){
var a [5]int
modify(&a)
fmt.Println(a)
}
输出：
[100 0 0 0 0]
切片：切片时数组的一个引用，因此切片时引用类型
切片的长度可以改变，因此切片是一个可变的数组
切片遍历方式和数组一样，可以用len()求长度
cap可以求出slice的最大容量，0<=len(slice)<=cap(array)，其中array是slice引用的数组
切片的定义：var 变量名 []类型
用数组直接切片进行初始化
package main
import "fmt"
func main(){
var slice []int
var array [5]int = [5]int{1,2,3,4,5}
slice = array[2:4]
fmt.Println(slice)
fmt.Println(len(slice))
fmt.Println(cap(slice))
}
输出：
[3 4]
2
3
切片的内存布局
image.png
通过make创建切片
var slice []type = make([]type,len)
slice := make(make[]type,len)
slice := make(make[]type,len,cap)
append操作切片
package main
import "fmt"
func testslice(){
var a [5]int =[5]int{1,2,3}
s := a[1:]
fmt.Printf("before len[%d] cap[%d]\n",len(s),cap(s)) //查看切片s的长度，容量
s[1] = 100
fmt.Printf("s=%p a[1]=%p\n",s ,&a[1]) //查看切片s的地址，a[1]的地址
fmt.Println("before a:",a)
s = append(s,1)
s = append(s,1)
s = append(s,1)
s = append(s,1)
s[1] = 1000
fmt.Println("after a:",a)
fmt.Println(s)
fmt.Printf("s=%p a[1]=%p\n",s,&a[1]) //查看切片s的地址，a[1]的地址
}
func main(){
testslice()
}
输出：
before len[4] cap[4]
s=0xc0420082a8 a[1]=0xc0420082a8
before a: [1 2 100 0 0]
after a: [1 2 100 0 0]
[2 1000 0 0 1 1 1 1]
s=0xc04200a1c0 a[1]=0xc0420082a8
如果append一个切片的话，需要展开。例如：a = append(a, b...)
切片的copy
package main
import "fmt"
func testcopy(){
var a = []int{1,2,3,4}
var b = make([]int,10)
copy(b,a)
fmt.Println(b)
}
func main(){
testcopy()
}
输出：
[1 2 3 4 0 0 0 0 0 0]
package main
import "fmt"
func testcopy(){
var a = []int{1,2,3,4}
var b = make([]int,1)
copy(b,a)
fmt.Println(b)
}
func main(){
testcopy()
}
输出：
[1]
copy是不会扩容的
string与slice
string底层就是一byte的数组，因此可以进行切片操作
package main
import "fmt"
func teststring(){
s := "hello world"
s1 := s[:5]
fmt.Println(s1,len(s1))
}
func main(){
teststring()
}
输出：
hello 5
string的底层布局
image.png
string的字符修改
package main
import "fmt"
func testmodifystring(){
s := "hello world"
s1 := []byte(s)
s1[0] = 'H'
str := string(s1)
fmt.Println(str)
}
func main(){
testmodifystring()
}
输出：
Hello world
