golang基础复合类型—切片

切片概述

简单来说可以将切片理解为动态数组，长度不固定，但是它不是数组。

切片的创建

1. 使用var

var name []Type
//例如
var s []int //[]中不需要指定特定长度

//输出
[]

2. 自动推导

name := []Type{
    
    }
//例如
s := []int{
    
    1,2,3}
//输出
[1,2,3]

3. 使用make函数

name := make([]Type,len,cap) //len是长度，cap是容量，cap可省略，此时len==cap
//例如
s := make([]int,3,5) //len(s)=3,cap(s)=5
//输出
[0,0,0]

切片初始化

1. 直接初始化

var s []int = []int{
    
    1,2,3}
s1 := []int{
    
    1,2,3,4}

2. append追加

s = append(s,4) //此时s = [1,2,3,4]

3. for循环初始化

s2 := make([]int,3,5)
for i:=0;i<len(s2);i++{
    
    
	s2[i] = i
	}
//s2 = [0,1,2]

4. 单项赋值与修改

s2[2] = 999
//s2 = [0,1,999]

切片的遍历

1. for…len 方式

s:=[]int{
    
    1,2,3}
 for i:=0;i<len(s);i++{
    
    
 		//可以输出每项s[i]
	}

2.for…range方式

s:=[]int{
    
    1,2,3}
for index,value := range s{
    
    
	//index 是索引下标，value是索引对应的值
}
//若不需要处理索引或者值可以使用 _ 省略，例如
for _,value := range s{
    
    
	//index 是索引下标，value是索引对应的值
}

切片的截取

s[n]             //切片s中索引位置为n的项
s[:]             //从切片s的索引位置0到len(s)-1处所获得的切片
s[low:]          //从切片s的索引位置low到len(s)-1处所获得的切片
s[:high]        //从切片s的索引位置0到high处（不包含high）所获得的切片m,len = high
s[low:high]     //从切片s的索引位置low到high处（不包含high）所获得的切片,len = high - low
s[low:high:max] //从切片s的索引位置low到high处（不包含high）所获得的切片,len = high - low ,cap = max-low,max 切片中最多能够容纳多少元素

//s[low:high:max] 演示
s := []int{
    
    1,2,3,4,5,6}
s1 := s[0:3:5]
//输出
//s1 = [1,2,3] 不包含下标为3的值 0 1 2
//len(s1) = 3
//cap(s1) = 5-0 = 5

容量cap通用计算公式 cap = max - low

修改截取切片的值会影响原切片的内容

s := []int{
    
    1,2,3,4,5,6}
s1 := s[0:3:5]  //s1并不是开辟了新的空间而是指向了原切片s
s1[0] = 999
//输出
s1 = [999,2,3]
s = [999,2,3,4,5,6]

append函数的基本使用

append函数在切片末尾添加元素

s := make([]int,5,8)
//s = [0,0,0,0,0] 
s = append(s,1)
//s = [0,0,0,0,0,1]
s = append(s,2)
s = append(s,3)
//s = [0,0,0,0,0,1,2,3]  len(s) = 8  cap = 8 已到达切片定义时的容量
s = append(s,4)
//s = [0,0,0,0,0,1,2,3,4] len(s) = 9  cap = 16
//当追加的元素超过定义切片的容量时，会自动扩容，一般扩容方式为上一下cap的两倍，即cap*2
//如果超过1024字节，每次扩容上一次的大约1/4.即约cap*（1+1/4）

copy函数的使用

//copy(切片1，切片2)
s1 := []int{
    
    1,2}
s2 := []int{
    
    3,4,5,6,7}
copy(s1,s2)
//s1 = [3,4]

//copy(切片1，切片2)
s1 := []int{
    
    1,2}
s2 := []int{
    
    3,4,5,6,7}
copy(s2,s1)
//s2 = [1,2,5,6,7]

切片作为函数参数

func main(){
    
    
	s := []int{
    
    1,2,3,4,5}
	init(s)
}
func init(num []int){
    
    
	for _,v := range num {
    
    
		fmt.printf("%d ",v)
	}
}
//输出
1 2 3 4 5

注意事项：在函数中修改切片的值，会影响到原切片，数组不会。

func main(){
    
    
	s := []int{
    
    1,2,3,4,5}
	init(s)
	fmt.println()
	fmt.println(s)
}
func init(num []int){
    
    
	for _,v := range num {
    
    
		fmt.printf("%d ",v)
	}
	num[0] = 999
}
//输出
1 2 3 4 5

[999,2,3,4,5]

切片案例1—计算特定数量的整型数据和

package main

import "fmt"

func main()  {
    
    
	var count int
	fmt.Println("请输入计算整数和的数量：")
	fmt.Scan(&count)
	num := make([]int,count)
	fmt.Println("请输入",count,"个整数：")
	for i:=0;i<len(num);i++{
    
    
		fmt.Scan(&num[i])
	}
	result := sum(num)
	fmt.Println("整数和为：",result)
}
func sum(num []int) int {
    
    
	result := 0
	for _,v := range num{
    
    
		result = result+v
	}
	return result
}

切片案例2—输出可变化长度的整型数组中的最大值

package main
import "fmt"

func main()  {
    
    
	var count int
	fmt.Println("请输入计算最大值的整数数量：")
	fmt.Scan(&count)
	num := make([]int,count)
	fmt.Println("请输入",count,"个整数：")
	for i:=0;i<len(num);i++{
    
    
		fmt.Scan(&num[i])
	}
	result := PrintMax(num)
	fmt.Println("最大整数为：",result)
}
func PrintMax(num []int) int {
    
    
	result := 0
	for _,v := range num{
    
    
		if v > result {
    
    
			result = v
		}
	}
	return result
}