老奶奶可以看懂的切片

前言

这里总结的Golang 笔记只适合有点编程基础的人看，比如Java

补充：

二维数组使用demo和遍历

package main

import "fmt"

func main() {
	// 遍历数组方式一
	var arr = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	for i:=0;i<len(arr);i++{
		for j:=0;j<len(arr[i]);j++{
			fmt.Printf("%d ", arr[i][j])
		}
		fmt.Println()
	}

	// 遍历数组方式二
	for i, v := range arr{
		for j, v1 := range v{
			fmt.Println("i: ", i, "j: ", j, "val: ", v1)
		}
	}
}

切片介绍

• 切片是一个数组的引用，因此切片是引用类型，遵守引用传递的机制。切片的底层其实就是维护了一个数组，而这个数组改变只能通过切片去改变。
• 切片使用和数组类似，遍历、访问、求长度等等操作都差不多。
• 切片的长度是可以变化的，因此切片可以理解为一个动态变换的数组。
• 切片的长度是可以变化的，因此切片是一个动态变换的数组。

两种使用方式

引用数组

func main() {
	var arr [5]int = [...]int{1, 2, 3, 4, 5}
	slice := arr[3:4]
	fmt.Println(len(slice))
	fmt.Println(cap(slice))// cap从切片第一个元素到基层数组的最后一个元素
	fmt.Println(slice)
}

切片的地址就是他引用数组的第一个元素的地址，这里的话也就是3这个下标。切片存储的是对应数组中元素的地址，修改切片其实也是修改数组。如下代码体现：

func main() {
	var arr [5]int = [5]int{1, 2, 3, 5, 4}
	slices := arr[3:5]
	fmt.Println(&arr[3])
	fmt.Println(&slices[0])
}

make方式创建切片

func main() {
	// 类型、长度、容量
	var slice []int = make([]int, 5, 10)
	fmt.Println(slice)
}

1. 通过make方式创建切片可以指定切片的大小和容量。
2. 如果没有给切片的各个元素赋值，那么就会使用默认值【int 0、float 0、string “”、bool false】
3. 通过make方式创建的切片对应的数组是由make底层进行维护的，对外不可见，即只能通过slice进行访问各个元素。

两种方式的区别

1. 第一种方式数组是事先存在的，程序员是可见的。
2. 通过make创建的切片，make也会创建数组，是由切片在底层进行维护。程序员是不可见的。

切片遍历

切片的遍历与数组一样，因为他底层本就是维护了一个数组，所以使用遍历数组的方式。

func main() {
	var arr []int = []int{1, 2, 3, 4, 5, 6}
	// 方式一 直接通过数组下标遍历
	for i:=0;i<len(arr);i++ {
		fmt.Printf("%d ", i)
	}
	fmt.Println()
	
	// 方式二 使用for……range
	for index, val:=range arr{
		fmt.Println("index: ", index, "    val:", val)
	}
}

注意事项

从arr数组下标为startIndex，取到下标为endIndex的元素（不含arr[endIndex]）。切片是可以动态增长的。cap是一个内置的函数，用于统计切片的容量，即最大可以存放多少个元素。切片定义完之后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用。切片引用切片的时候就相当于重新去引用数组，一定要注意长度和下标的选择。

切片内存情况

切片的底层就是数组，切片里面存的就是数组对应位置元素的指针，修改切片，所对应的数组或者切片对应位置的元素值都会发生变化。

切片是引用类型，所以在传递时候，遵守引用传递机制。扩容不会影响的是原来的切片，而是创建一个新的切片进行操作。

切片相关函数

append

内建函数append将元素追加到切片的末尾。若它有足够的容量，其目标就会重新切片以容纳新的元素。否则，就会分配一个新的基本数组。append返回更新后的切片，因此必须存储追加后的结果。

func main() {
	var slice1 []int = []int{100, 200, 300, 400, 500}
	slice2 := slice1[0 : 3]
	fmt.Println(len(slice2))
	slice2 = append(slice2, 600)
	fmt.Println(slice2)
        slice2 = append(slice1, slice2...) // 将slice2 追加在slice1之后
}

这里需要注意的是切片中cap的值是切片的时候起始位置的值到引用数组的长度相差。这样的话在进行append的时候判断是否大于cap，如果大于等于cap那么就需要扩容，创建一个新的数组将旧的数组中的值复制过去，小于的话那就是len+1就可以。

Copy

内建函数copy将元素从来源切片复制到目标切片中，也能将字节从字符串复制到字节切片中。copy返回被复制的元素数量，它会是 len(src) 和 len(dst) 中较小的那个。来源和目标的底层内存可以重叠。

func main() {
	var arr []int = []int{1, 2, 3}
	var slice = make([]int, 6)
	fmt.Println(cap(slice), len(slice))
	copy(slice, arr)
	fmt.Println(slice)
}

copy数组长度大的往小的传递copy，只拷贝够长度小的个数

切片的扩容规则

string和slice

string底层是一个byte数组，因此string也可以切片处理。string是不可变，就是不能通过切片slice[0] = ‘s’。

func main() {
	str := "Hello World!"
	slice := str[5:len(str) - 1]
	fmt.Println(slice)
	//slice[0] = 'Z' // string 是不可变得，所以这里赋值会产生错误
}

如何修改string中的某个字符

func main() {
	str := "Hello World!"
	slice := str[5:len(str) - 1]
	// 第一种如下的方法只能修改字母和数字的情况
	arr := []byte(str)
	arr[0] = 'Z'
	str = string(arr)
	fmt.Println(str)

	// 第二种处理所有类型情况
	arr := []rune(str)
	arr[0] = '中'
	str = string(arr)
	fmt.Println(str)
}

如果文章内容有错误，还请大佬们指导，防止误人子弟。继续冲冲冲！