数组&切片

数组：同一种数据类型的固定长度的序列
数组定义：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