Go语言之slice切面

切片

创建方式一

package main

import(
	"fmt"
)

// 切片
func main(){
	var arr = [...]int{1,2,3,4,5}
	// 声明一个切片
	slice := arr[2:4] // slice引用到arr这个数组的[1,3)下标
	fmt.Println("arr:",arr)
	fmt.Println("slice元素:",slice)
	fmt.Println("slice长度:",len(slice))
	fmt.Println("slice容量:",cap(slice)) // 就是数组的最大长度吧？但是使用make，可没有这个实际已经存在的数组
	fmt.Println()
	fmt.Println(&arr[2],"?=",&slice[0]) // 说明是引用类型传递
	slice[0] = 11
	fmt.Println(slice)

}

创建方式二

make([]类型,len,cap)

package main

import(
	"fmt"
)

// 切片的第二种创建方式
func main(){
	var slice []float64
	slice = make([]float64,3,6) // 切片的数据类型，切面的长度，切片的容量
	fmt.Println("slice赋值前",slice)
	slice[0] = 11
	slice[2] = 33
	fmt.Println("slice赋值后",slice)
	fmt.Println(cap(slice))
}

创建方式三

// 切片的第三种创建方式 var 名 []类型=[]类型{值}
	var arr1 []int = []int{1,2,3}
	fmt.Println("?",arr1)

区别：

1. 使用make创建出的切片，间接创建的数组不可见，由切片在底层维护。
2. 直接引用数组[?:?]，这个事先存在的数组被引用，更能观测到数组的第n个位置和切片的第一个位置地址值永远相同。
3. 直接声明出 var名[]int = []int{}，就能定义一个切片

slice使用细节

package main
import(
	"fmt"
)

func main(){
	// 普通for循环遍历切片
	var arr [5]int = [...]int{10,20,30,40,50}
	// slice := arr[1:5] // 20 30 40 50
	slice := arr[:] // 全部
	for i:=0;i<len(slice);i++{
		fmt.Println(slice[i])
	}
	// for-range遍历
	for index,value := range(slice){
		fmt.Println(index,"-",value)
	}

	// 切片还能继续切，嵌套
	slice2 := slice[1:3]
	fmt.Println(slice2) // 20 30 
	slice2[0] = 999 // 均变！！！
	fmt.Println(slice)
	fmt.Println(slice2)
}

slice内置函数append(原切片,追加1/多个元素)

追加后赋值给新切片

package main

import(
	"fmt"
	
)

func main(){
	var slice1 []int = []int{1,2,3,4,5}
	fmt.Println(slice1)

	slice2 := append(slice1,66,77,88) // 更像值拷贝，新创建一个切片，元切片不动。
	slice1[0] = 11

	fmt.Println("slice2",slice2) // [1 2 3 4 5 66 77 88]
	fmt.Println("slice1",slice1) // [11 2 3 4 5]
	
}

迭代给原切片

slice1 = append(slice1,100,200)

slice切片的copy(切片1,切片2)操作

	var slice3 []int = []int{1,2,3}
	slice4 := make([]int,10)
	
	fmt.Println("slice3",slice3)
	fmt.Println("slice4",slice4)
	// copy(slice3,slice4) // slice3 [0 0 0]
	copy(slice4,slice3) // 两参数数据类型必须是切片，先大后小，先硬后软
	fmt.Println("slice3后",slice3) // [1 2 3]
	fmt.Println("slice4后",slice4) // [1 2 3 0 0 0 0 0 0 0]

slice和string结合

string不可变，故想直接改变字符串中的某一字符不可能实现。
两种方法：

1. 使用字节数组，由于字符串底层通过字节数组实现，故byte1 := []byte(str)，通过修改byte数组，再转换成字符串类型string(byte1)赋值给str，输出str即可实现修改字符串
2. 使用类型[]rune，通过操作改变rune数组的n位置上元素后，再使用string(rune1)转换成字符串，输出

func main(){
	str := "lwt5"
	// 1
	var byte1 []byte = []byte(str) // 不能处理带有中文的字符串，因为byte范围-128-127
	byte1[3] = '6'
	str = string(byte1)
	fmt.Println(str) // lwt6

	// 2
	// 解决：使用类型[]rune，按字符处理而不是按字节处理，兼容中文.
	rune1 := []rune(str)
	rune1[3] = '六'
	// 再将rune1转换成字符串 输出
	str = string(rune1)
	fmt.Println(str) // lwt六
}