1 package main
 2 
 3 import "fmt"
 4 
 5 //切片定义 切片是基于数组类型的一层封装。它非常灵活，可以自动扩容，切片是一个引用类型
 6 func main() {
 7     var a [5]int // []内写了数字就是数组 没写数子就是切片
 8     var b []int //切片底层是基于数组类型做的一个封装 底层就是一个数组 所以数组的所有操作切片都可以用
 9     fmt.Println(a,b)
10     //Go语言用 nil来表示是否为空
11     if b == nil {
12         fmt.Println("b是一个空切片")
13     } else {
14         fmt.Printf("b不是一个空切片 b的值为 = %v\n", b)
15     }
16     //b[0] = 100 //这种写法是错误的，切片必须先初始化
17     var c [5]int= [5]int{1,0,0,8,6}
18     fmt.Println(" c的值为 = ", c)
19     b = c[0:3] //这种方式是基于已有的数组，对数组做一个切片
20     fmt.Println(" b的值为 = ", b)
21     //我们修改切片b里面的值
22     b[0] = 100
23     b[1] = 199
24     b[2] =88
25     fmt.Println(" b的值为 = ", b)
26     fmt.Println(" c的值为 = ", c) //发现c的值也跟着一起改变了，也再一次说明了切片是引用类型
27     d := c[:] //定义切片d
28     d[1] = 888 //其实修改的c数组里面下标为1的数值
29     fmt.Println(" b的值为 = ", b)
30     fmt.Println(" c的值为 = ", c) //发现c的值也跟着一起改变了，也再一次说明了切片是引用类型
31     //切片初始化的第二种方式
32     e := []int{3,2,1}
33     fmt.Println(e)
34 }

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     //注意[]中没有值 参数分别表示切片的类型，切片的长度，切片的容量
 7     //3 表示当前这个切片只有三个元素 10表示这个切片的底层是10个元素的数组 虽然arr[3]赋值会报错，但是可以通过append方法扩容
 8 
 9     arr := make([]int,3,10)
10     arr[0] = 10
11     arr[1] = 20
12     arr[2] = 30
13     arr = append(arr,11)
14     fmt.Println(arr)
15 
16     fmt.Println("--------分界线---------")
17 
18     a := make([]int, 5, 10)
19     a[0] = 33
20     fmt.Printf("a里面的值为:%v, a的长度为：%d, a的容量为：%d, a的地址为%p\n",a, len(a),cap(a),a)
21     a = append(a,11)
22     fmt.Printf("a里面的值为:%v, a的长度为：%d, a的容量为：%d, a的地址为%p\n",a, len(a),cap(a),a)
23     for i:=0;i<6;i++ {
24         a = append(a,33)
25         fmt.Printf("a里面的值为:%v, a的长度为：%d, a的容量为：%d, a的地址为%p\n",a, len(a),cap(a),a)
26     }
27 
28     fmt.Println("\n--------分界线---------")
29     //定义一个空切片
30     var b []int
31     fmt.Printf("b:%p, len=%d, cap=%d\n",b,len(b),cap(b))
32     //空切片地址是空，不能进行访问或者赋值 否则会报错
33     if b==nil {
34         fmt.Println("这是一个空切片")
35         //空切片可以append
36         b = append(b, 11)
37         fmt.Printf("b:%p, len=%d, cap=%d\n",b,len(b),cap(b))
38         b = append(b, 22)
39         fmt.Printf("b:%p, len=%d, cap=%d\n",b,len(b),cap(b))
40         b = append(b, 33)
41         fmt.Printf("b:%p, len=%d, cap=%d\n",b,len(b),cap(b))
42         b = append(b, 44)
43         fmt.Printf("b:%p, len=%d, cap=%d\n",b,len(b),cap(b))
44         b = append(b, 55)
45         fmt.Printf("b:%p, len=%d, cap=%d\n",b,len(b),cap(b))
46         //2倍扩容
47     }
48 
49 
50     fmt.Println("\n--------分界线---------")
51     //切片后面追加切片
52     c := []int{1,2,3}
53     d := []int{4,5,6}
54     e := append(c, d...)
55     fmt.Println(e)
56     e = append(e, 7,8,9)
57     fmt.Println(e)
58     //可以通过传切片来修改数组的值
59     //切片的复制、拷贝
60     //将d切片复制到c //只能copy长度前面的切片 并不会对其进行扩容
61     fmt.Println("c的值为",c)
62     copy(c, d)
63     fmt.Println("c的值为",c)
64     copy(c, e)
65     fmt.Println("c的值为",c)//
66 
67 }
68 // make 和 new 的区别
69 //

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "sort"
 6 )
 7 
 8 func main() {
 9 
10     a := [5]int{3,5,1,2,4}
11     fmt.Println("排序前的值为:", a)
12     //对int进行排序 排序需要传一个切片
13     sort.Ints(a[:])
14     fmt.Println("排序后的值为:", a)
15  
16     //当然也可以对字符串进行排序
17     strs := [5]string{"banana","apple","pear","watermelon","peach"}
18     fmt.Println("排序前的值为:", strs)
19     sort.Strings(strs[:])
20     fmt.Println("排序后的值为:", strs)
21 }