三天Golang快速入门—Slice切片

Slice切片

切片原理

• 由三个部分构成，指针、长度、容量
• 指针：指向slice第一个元素对应的数组元素的地址
• 长度：slice元素的数量，不能超过容量
• 容量：selice开始的位置到底层数据的结尾

package main

import "fmt"

func main() {
	//创建一个数组
	var array1 [5]int = [...]int{11, 22, 33, 44, 55}
	/*
		创建切片，通过对数组的索引切片
		s1是切片名
		array1[1:3]代表slice引用数组区间，索引1到索引3的值，注意取头不取尾，
	*/
	s1 := array1[1:4]
	fmt.Println(array1)
	fmt.Println(s1)
	fmt.Println(len(s1))
	fmt.Println(cap(s1))

}
//结果
[11 22 33 44 55]     //原本数组
[22 33 44]            //切片的值
3                    //切片元素长度
4                    //切片容量

需要说明：slice并不是数组或数组指针。只是通过内部指针和相关属性引用数组片段，实现可动态变化的序列。所以切片只是对数组的一个引用，是引用类型

//1.声明切片
var a []int
//2. 类型推导声明并初始化切片
b := []int{}
//3. make创建切片
// 内置make函数，参数（类型，len，cap）cap必须大于len，容量可以省略，默认等于长度
var c []int = make([]int,0)
//4.从数组切片
d := [5]int{1,2,3,4,5}
var d2 []int
d2 = d[1:4]

切片遍历

和数组的变量是一样的

package main

import "fmt"

func main() {
	arr := [5]int{11, 22, 33, 44, 55}
	s1 := arr[1:4]
	// for循环
	for i := 0; i < len(s1); i++ {
		fmt.Printf("s1[%v]=%v\n", i, s1[i])
	}
	fmt.Println()

	// for range方式
	for i, v := range s1 {
		fmt.Printf("索引i=%v 值v=%v\n", i, v)
	}

}

append函数操作切片

• append可以为切片动态添加元素，每个切片会指向一个底层数组
• 当底层数组不能容纳新增的元素时，切片会自动进行扩容，重新指向一个新的底层数据，且以2倍的容量重新分配数组

append添加

package main

import "fmt"

func main() {
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v len:%d cap:%d ptr:%p\n", numSlice, len(numSlice),
			cap(numSlice), numSlice)
	}

}
/*
[0] len:1 cap:1 ptr:0xc0000140a8
[0 1] len:2 cap:2 ptr:0xc0000140f0                  
[0 1 2] len:3 cap:4 ptr:0xc00000e200                
[0 1 2 3] len:4 cap:4 ptr:0xc00000e200              
[0 1 2 3 4] len:5 cap:8 ptr:0xc000018280            
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc000018280          
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc000018280        
[0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0xc000018280      
[0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0xc000102000
*/

append追加多个

package main

import "fmt"

func main() {
	var citySlice []string
	citySlice = append(citySlice, "上海")             // 追加一个元素
	citySlice = append(citySlice, "北京", "广州", "杭州") // 追加多个元素

	a := []string{"成都", "重庆"}
	citySlice = append(citySlice, a...) // 追加切片

	fmt.Println(citySlice)
}
/*
[上海 北京 广州 杭州 成都 重庆]
*/

切片中删除元素

package main

import "fmt"

func main() {
	a := []int{10, 11, 20, 21, 22, 40}
	a = append(a[:2], a[3:]...) //删除索引为2的元素
	fmt.Println(a)
}
//[10 11 21 22 40]

切片合并

package main

import "fmt"

func main() {
	a1 := []int{2, 4, 8}
	a2 := []int{1, 3, 7}
	a1 = append(a1, a2...)
	fmt.Println(a1)
}
//[2 4 8 1 3 7]

string和slice的联系

//string底层就是byte数组 因此string同样可以进行切片处理
package main
import "fmt"
func main() {
    str1 := "yugo niubi"
    //对str1进行切片
    s1 := str1[:4]
    fmt.Println(s1)//yugo
}

2)stirng修改的两种方式
package main
import (
    "fmt"
)
func main() {
    str1 := "yugo niubi"
    //string是不可变的，也无法通过切片修改值
    //str1[0] = 's'  编译器失败
    //修改string的方法，需要string转化为[]byte，修改后转为string
    arr1 := []byte(str1) //类型强转
    arr1[0] = 'g'
    str1 = string(arr1)
    fmt.Printf("str1=%v\n", str1)
    //[]byte只能处理英文和数字，不能处理汉字，汉字3个字节，会出现乱码
    //将string转为[]rune，按字符处理，兼容汉字
    arr2 := []rune(str1)
    arr2[0] = '于'
    str1 = string(arr2)
    fmt.Printf("str1=%v\n", str1)
}