Go语言学习、切片定义和使用

r囧r小猫 2023-06-25 14:26 0阅读 0赞

一、切片的定义和使用

package main
    
    import "fmt"
    
    func main() {
    	//数组定义 var 数组名 [元素个数] 数据类型
    	//切片定义 var 切片名 [] 数据类型
    	var  s [] int
    	fmt.Println(s)
    }

输出结果

[]

可以看到，我们在上面的程序中，将切片的定义和数组的定义做了对比，切片的定义时，不需要任何元素个数

当定义完成切片后，我们做打印，发现切片为空，因没有任何数据

package main
    
    import "fmt"
    
    func main() {
    	//数组定义 var 数组名 [元素个数] 数据类型
    	//切片定义 var 切片名 [] 数据类型
    	var  s [] int
    	s[0] = 123 //这里直接给切片复制，会报错，因为切片的长度为零
    	fmt.Println(s)
    }

输出结果：

panic: runtime error: index out of range
    
    goroutine 1 [running]:
    main.main()
    	D:/go_work/切片.go:9 +0x17

我们定义完切片后，直接通过切片下标进行赋值操作，会出现上述错误，因为这时定义的切片长度为0，不能直接赋值

我们通过下面的方法，进行切片的定义

package main
    
    import "fmt"
    
    func main() {
    	//make([] 数据类型, 切片长度)
    	s := make([] int , 5) //通过自动推导类型，创建一个切片，类型为int，长度为5
    	//通过下标为切片赋值
    	s[0] = 123
    	s[1] = 456
    	s[2] = 789
    	fmt.Println(s)
     }

二、make方法，创建切片操作，输出结果：

[123 456 789 0 0]

我们在没有对切片的元素进行赋值时，该元素的结果为0，也会被打印。

通过len查看切片长度

//通过len查看切片的长度
    	fmt.Println(len(s))

结果：

是我们定义的长度。

三、切片的扩展：

package main
    
    import "fmt"
    
    func main() {
    	//make([] 数据类型, 切片长度)
    	s := make([] int , 5) //通过自动推导类型，创建一个切片，类型为int，长度为5
    	//通过下标为切片赋值
    	s[0] = 123
    	s[1] = 456
    	s[2] = 789
    	s[3] = 111
    	s[4] = 222
    	//s[5] = 333 //我们不能直接给切片进行，越界赋值，会直接报越界错误
    	//但是通过append，可以直接添加切片元素
    	s = append(s, 333)
    	fmt.Println(s)
    
     }

输出结果：

[123 456 789 111 222 333]

我们可以看到，通过，s\[5\]  = 333 这种方式，不能直接给切片进行扩展操作，如果想要给一个长度已满的切片进行赋值操作，则需要我们通过append方法，进行添加元素操作。

我们在看看，添加完后的切片长度：

fmt.Println(len(s))

结果为：6

也可以通过append,添加多个元素，需要在元素值后面用逗号隔开：

s = append(s, 333,444,555)

四、切片的遍历操作：

1、

package main
 
 import "fmt"
 
 func main() {
 	//make([] 数据类型, 切片长度)
 	s := make([] int , 5) //通过自动推导类型，创建一个切片，类型为int，长度为5
 	//通过下标为切片赋值
 	s[0] = 123
 	s[1] = 456
 	s[2] = 789
 	s[3] = 111
 	s[4] = 222
 	// 切片的遍历
 	for i:=0; i<len(s);i++{
 		fmt.Println(s[i])
 	}
 }

结果：

123
    456
    789
    111
    222

通过循环遍历出切片的值

2、

for i,v:=range s{
    		fmt.Println(i,v)
    	}

结果：

0 123
    1 456
    2 789
    3 111
    4 222

五、切片初始化操作：

我们在不适用make创建切片的时候，可以直接对切片进行初始化操作。

package main
    
    import "fmt"
    
    func main() {
    	//这种创建切片的方式，跟创建数组类似
    	//不写元素个数的，叫切片，必须写元素个数的叫数组
    	//切片与数组都是连续的存储空间，切片可以扩展，元素不能扩展。
    	//切片在内存中存储的区域是堆区。数组的数据存储在内存中的栈区
    	var s [] int = []int{1,2,3,4,5}
    	fmt.Println(s)
    	
    }

结果：

[1 2 3 4 5]

六、切片的容量：

package main
    
    import "fmt"
    
    func main() {
    	var s [] int = []int{1,2,3,4,5}
    	fmt.Println(s)
    	//切片的长度
    	fmt.Println("长度 = ",len(s))
    	// 切片的容量
    	fmt.Println("容量 = ", cap(s))
    }

结果：

[1 2 3 4 5]
    长度 =  5
    容量 =  5

可以看到，我们使用cap方法来获得切片容量大小

我们在s中，添加一个元素

package main
    
    import "fmt"
    
    func main() {
    	var s [] int = []int{1,2,3,4,5}
    	fmt.Println(s)
    	//添加元素：
    	s = append(s, 6,7,8,9)
    
    	//切片的长度
    	fmt.Println("长度 = ",len(s))
    	// 切片的容量
    	fmt.Println("容量 = ", cap(s))
    
    	//添加一个元素到s中
    	s = append(s, 10,11,12,13)
    	//切片的长度
    	fmt.Println("长度 = ",len(s))
    	// 切片的容量
    	fmt.Println("容量 = ", cap(s)) 
    }

输出结果：

[1 2 3 4 5]
    长度 =  9
    容量 =  12
    长度 =  13
    容量 =  24

可以看到，容量一定是大于等于长度的，且容量的每次扩展是上一次容量的倍数。

当容量大小，超过当前容量，才会自动扩展。

如果整体数据，没有超过1024个字节，每次扩展为上一次的倍数，如果超过1024，则每次扩展是上次的四分之一。

举例：

package main
 
 import "fmt"
 
 func main() {
 	 s := make([]int, 0 ,1) //容量为1
 	 oldCap := cap(s)
 	 for i:=0; i<20; i++{
 	 	s = append(s,i)
 	 	newCap:= cap(s)
 	 	if oldCap < newCap{
 	 		fmt.Printf("cap: %d========> %d\n", oldCap, newCap)
 	 		oldCap = newCap
 		}
 	 }
 }

输出结果：

cap: 1========> 2
    cap: 2========> 4
    cap: 4========> 8
    cap: 8========> 16
    cap: 16========> 32

通过上面这个例子，我们可以看到，是切片的扩容是通过2倍进行的

在看下，下面这个例子：

package main
 
 import "fmt"
 
 func main() {
 	 s := make([]int, 0 ,1) //容量为1
 	 oldCap := cap(s)
 	 for i:=0; i<200000; i++{ //我们吧循环条件修改变大
 	 	s = append(s,i)
 	 	newCap:= cap(s)
 	 	if oldCap < newCap{
 	 		fmt.Printf("cap: %d========> %d\n", oldCap, newCap)
 	 		oldCap = newCap
 		}
 	 }
 }

结果：

cap: 512========> 1024  //两倍扩容
    cap: 1024========> 1344 //不再是两倍扩容
    cap: 1344========> 1696
    cap: 1696========> 2368
    cap: 2368========> 3072
    cap: 3072========> 4096
    cap: 4096========> 5120
    cap: 5120========> 6816
    cap: 6816========> 10240
    cap: 10240========> 14336
    cap: 14336========> 18432
    cap: 18432========> 24576
    cap: 24576========> 30720
    cap: 30720========> 38912
    cap: 38912========> 49152
    cap: 49152========> 61440
    cap: 61440========> 77824
    cap: 77824========> 98304
    cap: 98304========> 122880
    cap: 122880========> 153600
    cap: 153600========> 192512
    cap: 192512========> 241664

当容量小于1024时是按照2倍容量扩容，当大于等于1024是不是按照2倍容量扩容。

七、切片的截取：

首先说一下切片的截取操作，所谓截取就是从切片中获取指定的数据。

我们通过如下程序给大家解释一下：

package main
    
    import "fmt"
    
    func main() {
    	//定义切片，并完成初始化
    	s:= []int {10,20,30,40,50}
    
    	// 从切片s中截取数据
    	slice:= s[0:3:5]
    	fmt.Println(slice)
    }

结果：

[10 20 30]

s\[0:3:5\]是什么意思呢？

我们可以使用s\[low:high:max\]来表示

第一个数（low）表示下标的起点（从该位置开始截取），如果low取值为0表示从第一个元素开始截取，也就是对应的切片s中的10

第二个数(high)表示取到哪结束，也就是下标的终点（不包含该位置），3表示取出下标是0,1,2的数据（10,20,30），不包括下标为3的数据，那么也就是说取出的数据长度是3. 可以根据公式：3-0 计算(len=high-low)，也就是第二个数减去第一个数，差就是数据长度。在这里可以将长度理解成取出的数据的个数。

第三个数用来计算容量，所谓容量:是指切片目前可容纳的最多元素个数。通过公式5-0计算(cap=max-low)，也就是第三个数据减去第一个数。该案例中容量为5

关于切片的截取还有其它的操作，如下图所示：

<table style="margin-left:.4pt;width:448.4pt;"> 
 <tbody> 
 <tr> 
 <td style="width:85.4pt;"> 操作 </td> 
 <td style="width:363pt;"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[n] </td> 
 <td style="width:363pt;"> 切片s中索引位置为n的项 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[:] </td> 
 <td style="width:363pt;"> 从切片s的索引位置0到len(s)-1处所获得的切片 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[low:] </td> 
 <td style="width:363pt;"> 从切片s的索引位置low到len(s)-1处所获得的切片 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[:high] </td> 
 <td style="width:363pt;"> 从切片s的索引位置0到high处所获得的切片，len=high </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[low:high] </td> 
 <td style="width:363pt;"> 从切片s的索引位置low到high处所获得的切片，len=high-low </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[low:high:max] </td> 
 <td style="width:363pt;"> 从切片s的索引位置low到high处所获得的切片，len=high-low，cap=max-low </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> len(s) </td> 
 <td style="width:363pt;"> 切片s的长度，总是&lt;=cap(s) </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> cap(s) </td> 
 <td style="width:363pt;"> 切片s的容量，总是&gt;=len(s) </td> 
 </tr> 
 </tbody> 
</table>

通过下面的例子，我们简单的演示一下：

1、

package main
    
    import "fmt"
    
    func main() {
    	//定义切片，并完成初始化
    	s:= []int {0,1,2,3,4,5,6,7,8,9}
    	// 从切片s中截取数据
    	slice:= s[:] //不指定容量和长度一样
    	fmt.Println("slice = ",slice)
    	fmt.Printf("len = %d, cap = %d\n", len(slice), cap(slice))
    }

输出结果：

slice =  [0 1 2 3 4 5 6 7 8 9]
    len = 10, cap = 10

2、

package main
    
    import "fmt"
    
    func main() {
    	//定义切片，并完成初始化
    	s:= []int {0,1,2,3,4,5,6,7,8,9}
    	// 从切片s中截取数据
    	slice:= s[3:] //从下标3开始
    	fmt.Println("slice = ",slice)
    	fmt.Printf("len = %d, cap = %d\n", len(slice), cap(slice))
    }

结果：

slice =  [3 4 5 6 7 8 9]
    len = 7, cap = 7

3、

package main
    
    import "fmt"
    
    func main() {
    	//定义切片，并完成初始化
    	s:= []int {0,1,2,3,4,5,6,7,8,9}
    	// 从切片s中截取数据
    	slice:= s[:6] //从下0开始，取6个元素，容量是10
    	fmt.Println("slice = ",slice)
    	fmt.Printf("len = %d, cap = %d\n", len(slice), cap(slice))
    }

结果：

slice =  [0 1 2 3 4 5]
    len = 6, cap = 10

4、

package main
    
    import "fmt"
    
    func main() {
    	//定义切片，并完成初始化
    	s:= []int {0,1,2,3,4,5,6,7,8,9}
    	// 从切片s中截取数据
    	slice:= s[2:5] //从下2开始（包含该元素），取到下标5为止（不包含该元素），切片长度为3，容量是8，10-2
    	fmt.Println("slice = ",slice)
    	fmt.Printf("len = %d, cap = %d\n", len(slice), cap(slice))
    }

结果:

slice =  [2 3 4]
    len = 3, cap = 8

八、copy函数使用

针对切片操作常用的方法除了append( )方法以外，还有copy方法.

基本语法：copy(切片1，切片2)

将第二个切片里面的元素，拷贝到第一个切片中。

下面通过一个案例，看一下该方法的使用：

package main
    
    import "fmt"
    
    func main() {
    	s1 := []int{1,2}
    	s2 := []int{4,5,6,7,8}
    	copy(s2,s1) //将s1中的元素，拷贝到s2中
    	fmt.Print(s2)
    }

结果：

[1 2 6 7 8]

通过以上结果可以分析出，直接将1切片中两个元素拷贝到s2元素中相同的位置。而s2原有的元素备替换掉。

在看下面的：

package main
    
    import "fmt"
    
    func main() {
    	s1 := []int{1,2}
    	s2 := []int{4,5,6,7,8}
    	copy(s1,s2) //将s2中的元素，拷贝到s1中
    	fmt.Print(s1)
    }

输出结果：

[4 5]

而，将s2拷贝到s1，则会吧s1中的元素替换掉。

今天就讲到这里。感谢各位阅读，欢迎点赞评论。谢谢！！