GO数组和切片

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

func main() {
    a:=[3] int{2:1,1:3}
    b:=[...] int {1:1,2:2,5:5}
    var c [2] int= [2] int {1,3}
    fmt.Println(a) //[0 3 1]
    fmt.Println(b) //[0 1 2 0 0 5]
    fmt.Println(c)//[1 3]
}

func main() {
    var c [2] int= [2] int {1,3}
    var p *[2] int=&c
    fmt.Println(p) //指向数组的指针 &[1 3]
    x,y:=1,2
    a:=[2] * int{&x,&y}
    fmt.Println(a) //[0xc0820022a0 0xc0820022a8] 指针数组
}

func main() {
    a:=[10] int{}
    a[1]=2
    fmt.Println(a)  //[0 2 0 0 0 0 0 0 0 0]
    p:=new([10] int)
    p[1]=2
    fmt.Println(p) //&[0 2 0 0 0 0 0 0 0 0]
}

Go多维数组

func main() {
    a := [2][3]int{
            {1, 1, 1},
            {2, 2, 2}} 
    fmt.Println(a)
}

go语言版冒泡排序

func main() {
    arr:=[...]int{3,1,8,2,7}
    fmt.Println(arr)
    len:=len(arr)
    count:=0  //交换次数
    for i:=0;i<len;i++{
        for j:=i+1;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) //4
}

 

循环里可以
func main() {
    for i:=0;i<3;i++{
        v:=1
        fmt.Println(&v) //每次一个新地址
    }
}
在循环外
v:=1
v:=1
是错误的

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

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

func main() {
    var s [10] int=[10]int{1,2,3,4,5,6,7,8,9,10}
    fmt.Println(s)
//    s1:=s[5:10]     //前闭后开 索引包含5不包含10,从索引5取到最后3种形式
//    s1:=s[5:len(s)]
    s1:=s[5:]
    s2:=s[:5]
    fmt.Println(s1)    //[6 7 8 9 10]
    fmt.Println(s2)//[1 2 3 4 5]
}

 

func main() {
    s1:=make([]int,3,10)
    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[2:5]
    fmt.Println(s1)//[c d e]
    fmt.Println(len(s1),cap(s1))//3 8 指向的是1个连续的内存块
    s2:=s1[:2]
    fmt.Println(s2)//[c d]
    fmt.Println(len(s2),cap(s2))//2 8
    s3:=s2[1:]
    fmt.Println(s3)//[d]
    fmt.Println(len(s3),cap(s3))//1 7
}

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

 

unc main() {
    s1:=make([]int,3,6)
    fmt.Printf("%p\r\n",s1)//0xc082005da0
    s1=append(s1,1,2,3)
    fmt.Printf("%v,%p\r\n",s1,s1)//[0 0 0 1 2 3],0xc082005da0
    s1=append(s1,4,5,6)
    fmt.Printf("%v,%p",s1,s1)//[0 0 0 1 2 3 4 5 6],0xc08203a120(地址变了,重新分配了)
}

 

func main() {
    a:=[]int{1,2,3,4,5}
    s1:=a[2:5] //[3 4 5]
    s2:=a[1:3] //[2 3]
    fmt.Println(s1,s2)
    s1[0]=9
    fmt.Println(s1,s2,a)//[9 4 5] [2 9] [1 2 9 4 5]
    a[1]=7
    fmt.Println(s2,a)//[7 9] [1 7 9 4 5]
}

func main() {
    a:=[]int{1,2,3,4,5}
    s1:=a[2:5] //[3 4 5]
    s2:=a[1:3] //[2 3]
    fmt.Println(s1,s2)
    s2=append(s2,1,1,1,1,1,1,1,1,1,1)
    s1[0]=9
    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{1,2,3,4,5,6}
    s2:=[]int{7,8,9}
//    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[2:],s1)
    fmt.Println(s2)//[7 8 1]    
}

 

转载于:https://www.cnblogs.com/HKUI/p/4796194.html