GO数组和切片

数组Array
定义数组的格式:var <varName>[n]<type>,n>0
数组长度也是类型的一部分,因此具有不同长度的数组为不同类型,
不同类型的不能相互赋值
注意区分指向数组的指针和指针数组
数组在GO中为值类型
数组之间(相同类型)可使用==或!=进行比较,但不可以使用>或<
可以使用new来创建数组,此方法返回一个指向数组的指针
go支持多维数组

func main() {

    a:=[] int{:,:}

    b:=[...] int {:,:,:}

    var c [] int= [] int {,}

    fmt.Println(a) //[0 3 1]

    fmt.Println(b) //[0 1 2 0 0 5]

    fmt.Println(c)//[1 3]

}

func main() {

    var c [] int= [] int {,}

    var p *[] int=&c

    fmt.Println(p) //指向数组的指针 &[1 3]

    x,y:=,

    a:=[] * int{&x,&y}

    fmt.Println(a) //[0xc0820022a0 0xc0820022a8] 指针数组

}

func main() {

    a:=[] int{}

    a[]=

    fmt.Println(a)  //[0 2 0 0 0 0 0 0 0 0]

    p:=new([] int)

    p[]=

    fmt.Println(p) //&[0 2 0 0 0 0 0 0 0 0]

}

Go多维数组

func main() {

    a := [][]int{

            {, , },

            {, , }}

    fmt.Println(a)

}

go语言版冒泡排序

func main() {

    arr:=[...]int{,,,,}

    fmt.Println(arr)

    len:=len(arr)

    count:=  //交换次数

    for i:=;i<len;i++{

        for j:=i+;j<len;j++{

            if arr[i]>arr[j]{

                tmp:=arr[j]

                arr[j]=arr[i]

                arr[i]=tmp

                count++

            }

        }

    }

    fmt.Println(arr)

    fmt.Println(count) //

}

循环里可以

func main() {

    for i:=;i<;i++{

        v:=

        fmt.Println(&v) //每次一个新地址

    }

}

在循环外

v:=

v:=

是错误的

切片Slice
本身并不是数组,它指向底层的数组
作为变长数组的替代方案,可以关联底层数组的局部或全部
为引用类型
可以直接创建或者从底层数组获取生成
使用len()获取元素个数,cap()获取容量
一般使用make()创建
如果多个slice指向相同底层数组,其中一个值改变会影响全部

make([]type ,len,cap)
其中cap可以省略,省略时和len值相同
len表示存储的个数,cap表示容量

func main() {

    var s [] int=[]int{,,,,,,,,,}

    fmt.Println(s)

//    s1:=s[5:10]     //前闭后开 索引包含5不包含10,从索引5取到最后3种形式

//    s1:=s[5:len(s)]

    s1:=s[:]

    s2:=s[:]

    fmt.Println(s1)    //[6 7 8 9 10]

    fmt.Println(s2)//[1 2 3 4 5]

}

func main() {

    s1:=make([]int,,)

    fmt.Println(len(s1),cap(s1))//3 10

    fmt.Println(s1)//[0 0 0]

}

Reslice
Reslice时索引以被slice的切片为准
索引不可以超过被slice切片的容量的cap()值 //超出内存块了
索引越界不会导致底层数组的重新分配而是引发错误

func main() {

    a:=[]string{"a","b","c","d","e","f","g","h","i","j"}

    s1:=a[:]

    fmt.Println(s1)//[c d e]

    fmt.Println(len(s1),cap(s1))//3 8 指向的是1个连续的内存块

    s2:=s1[:]

    fmt.Println(s2)//[c d]

    fmt.Println(len(s2),cap(s2))//2 8

    s3:=s2[:]

    fmt.Println(s3)//[d]

    fmt.Println(len(s3),cap(s3))//1 7

}

Append
可以在slice尾部追加元素
可将一个slice追加在另一个slice的尾部
如果最终长度未超过追加到slice的容量则返回原始slice
如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据

unc main() {

    s1:=make([]int,,)

    fmt.Printf("%p\r\n",s1)//0xc082005da0

    s1=append(s1,,,)

    fmt.Printf("%v,%p\r\n",s1,s1)//[0 0 0 1 2 3],0xc082005da0

    s1=append(s1,,,)

    fmt.Printf("%v,%p",s1,s1)//[0 0 0 1 2 3 4 5 6],0xc08203a120(地址变了,重新分配了)

}

func main() {

    a:=[]int{,,,,}

    s1:=a[:] //[3 4 5]

    s2:=a[:] //[2 3]

    fmt.Println(s1,s2)

    s1[]=

    fmt.Println(s1,s2,a)//[9 4 5] [2 9] [1 2 9 4 5]

    a[]=

    fmt.Println(s2,a)//[7 9] [1 7 9 4 5]

}

func main() {

    a:=[]int{,,,,}

    s1:=a[:] //[3 4 5]

    s2:=a[:] //[2 3]

    fmt.Println(s1,s2)

    s2=append(s2,,,,,,,,,,)

    s1[]=

    fmt.Println(s1,s2,a)//[9 4 5] [2 3 1 1 1 1 1 1 1 1 1 1] [1 2 9 4 5]

    //s2 append后长度超出容量 获得新地址不再指向a,s1的改变对其不影响

}

copy

func main() {

    s1:=[]int{,,,,,}

    s2:=[]int{,,}

//    copy(s1,s2) //将s2复制到s1里

//    fmt.Println(s1,s2) //[7 8 9 4 5 6] [7 8 9]

//    copy(s2,s1)

//    fmt.Println(s2)// [1 2 3]

    copy(s2[:],s1)

    fmt.Println(s2)//[7 8 1]

}

巴特西

GO数组和切片

最新文章

热门文章