Go切片

package main

import "fmt"

func main() {
	/*
	数组array：
		存储一组相同数据类型的数据结构。
			特点：定长

	切片slice：
		同数组类似，也叫做变长数组或者动态数组。
			特点：变长
		是一个引用类型的容器，指向了一个底层数组。
	
	切片创建：
		var 切片名 [] 数据类型
	
		var 切片名 = [] 数据类型{元素1，元素2.。。}
	
		切片名 := []数据类型{元素。。。}
	
		切片名 := []数据类型（变量）
		
		切片名 := make([]int, 5 ,10)
			第一个参数：类型
				slice，map，chan
			第二个参数：长度len
				实际存储元素的数量
			第三个参数：容量cap
				最多能够存储的元素的数量
	
	append()，专门用于向切片的尾部追加元素
		slice = append(slice, elem1, elem2)
		slice = append(slice, anotherSlice...)
	 */
	//1.数组
	arr := [4]int{1, 2, 3, 4} //定长
	fmt.Println(arr)          //[1 2 3 4]

	//2.切片
	var s1 []int
	fmt.Println(s1) //[]

	s2 := []int{1, 2, 3, 4} //变长
	s100 := []int(s2)
	fmt.Println("s100-->", s100)
	fmt.Printf("%p--%p", s2, s100) //0xc000060160--0xc000060160
	fmt.Println(s2)                //[1 2 3 4]
	fmt.Printf("%T,%T\n", arr, s2) //[4]int,[]int

	//make创建切片
	s3 := make([]int, 3, 8)
	fmt.Println(s3)                               //[0 0 0]
	fmt.Printf("容量：%d,长度：%d\n", cap(s3), len(s3)) //容量：8,长度：3
	s3[0] = 1
	s3[1] = 2
	s3[2] = 3
	fmt.Println(s3) //[1 2 3]
	//fmt.Println(s3[3]) //panic: runtime error: index out of range

	//append()
	s4 := make([]int, 0, 5)
	fmt.Println(s4) //[]
	s4 = append(s4, 1, 2)
	fmt.Println(s4) //[1 2]
	//s4指向新的底层数组
	s4 = append(s4, 3, 4, 5, 6, 7)
	fmt.Println(s4)        //[1 2 3 4 5 6 7]
	s4 = append(s4, s3...) //[1 2 3 4 5 6 7 1 2 3]
	fmt.Println(s4)

	//遍历切片
	for i := 0; i < len(s4); i++ {
		fmt.Println(s4[i])
	}

	for i, v := range s4 {
		fmt.Printf("%d-->%d\n", i, v)
	}

}

package main

import "fmt"

func main() {
	/*
	切片Slice：
		1.每一个切片引用了一个底层数组
		2.切片本身不存储任何数据，都是这个底层数组存储，所以修改切片也就是修改这个数组中的数据
		3.当向切片中添加数据时，如果没有超过容量，直接添加，如果超过容量，自动扩容(成倍增长)
		4.切片一旦扩容，就是重新指向一个新的底层数组
	 */
	s1 := []int{1, 2, 3}
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:3,cap:3
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 4, 5)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:5,cap:6
	fmt.Printf("%p\n", s1)

	s1 = append(s1,6,7,8)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:8,cap:12
	fmt.Printf("%p\n", s1)

	s1 = append(s1,9,10)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:10,cap:12
	fmt.Printf("%p\n", s1)

	s1 = append(s1,11,12,13,14,15)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:15,cap:24
	fmt.Printf("%p\n", s1)
}

package main

import "fmt"

func main() {
	/*
	slice := arr[start:end]
	 	切片中的数据：[start,end)
	 	arr[:end],从头到end
	 	arr[start:]从start到末尾

	 从已有的数组上，直接创建切片，该切片的底层数组就是当前的数组。
	 	长度是从start到end切割的数据量。
		但是容量从start到数组的末尾。
	  */
	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("----------1.已有数组直接创建切片--------------------")
	s1 := a[:5]  //1-5
	s2 := a[3:8] //4-8
	s3 := a[5:]  // 6-10
	s4 := a[:]   // 1-10 
	fmt.Println("a:", a) //a: [1 2 3 4 5 6 7 8 9 10]
	fmt.Println("s1:", s1) //s1: [1 2 3 4 5]
	fmt.Println("s2:", s2) //s2: [4 5 6 7 8]
	fmt.Println("s3:", s3) //s3: [6 7 8 9 10]
	fmt.Println("s4:", s4) //s4: [1 2 3 4 5 6 7 8 9 10]

	fmt.Printf("%p\n",&a) //0xc0000680a0
	fmt.Printf("%p\n",s1) //0xc0000680a0

	fmt.Println("----------2.长度和容量--------------------")
	fmt.Printf("s1	len:%d,cap:%d\n",len(s1),cap(s1)) //s1	len:5,cap:10
	fmt.Printf("s2	len:%d,cap:%d\n",len(s2),cap(s2)) //s2	len:5,cap:7
	fmt.Printf("s3	len:%d,cap:%d\n",len(s3),cap(s3)) //s3	len:5,cap:5
	fmt.Printf("s4	len:%d,cap:%d\n",len(s4),cap(s4)) //s4	len:10,cap:10


	fmt.Println("----------3.更改数组的内容--------------------")
	a[4] =100
	fmt.Println(a) //[1 2 3 4 100 6 7 8 9 10]
	fmt.Println(s1) //[1 2 3 4 100]
	fmt.Println(s2) //[4 100 6 7 8]
	fmt.Println(s3) //[6 7 8 9 10]

	fmt.Println("----------4.更改切片的内容--------------------")
	s2[2] =200
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)

	fmt.Println("----------4.更改切片的内容--------------------")
	s1 = append(s1,1,1,1,1)
	fmt.Println(a) //[1 2 3 4 100 1 1 1 1 10]
	fmt.Println(s1) //[1 2 3 4 100 1 1 1 1]
	fmt.Println(s2) //[4 100 1 1 1]
	fmt.Println(s3) //[1 1 1 1 10]
	fmt.Println("----------5.添加元素切片扩容--------------------")
	fmt.Println(len(s1),cap(s1)) //9 10

	s1 = append(s1,2,2,2,2,2)
	fmt.Println(a) //[1 2 3 4 100 1 1 1 1 10]
	fmt.Println(s1) //[1 2 3 4 100 1 1 1 1 2 2 2 2 2]
	fmt.Println(s2) //[4 100 1 1 1]
	fmt.Println(s3) //[1 1 1 1 10]
	fmt.Println(len(s1),cap(s1)) //14 20
	//扩容之后指向了新的底层数组的地址
	fmt.Printf("%p\n",s1) //0xc000096000
	fmt.Printf("%p\n",&a) //0xc0000680a0
}

package main

import "fmt"

func main() {
	/*

	按照类型来分：
		基本类型：int，float，string，bool
		复合类型：array，slice，map，struct，pointer，function，chan

	按照特点来分：
		值类型：int，float，string，bool，array
			传递的是数据副本
		引用类型：Slice
			传递的地址,多个变量指向了同一块内存地址，



	所以：切片是引用类型的数据，存储了底层数组的引用
	 */

	//1.数组：值类型
	a1 := [4]int{1,2,3,4}
	a2 := a1  //值传递：传递的是数据
	fmt.Println(a1,a1) //[1 2 3 4] [1 2 3 4]
	a1[0] =100 
	fmt.Println(a1,a2) //[100 2 3 4] [1 2 3 4]

	//2.切片：引用类型
	s1 :=[]int{1,2,3,4}
	s2 := s1
	fmt.Println(s1,s2) //[1 2 3 4] [1 2 3 4]
	s1[0] =100
	fmt.Println(s1,s2) //[100 2 3 4] [100 2 3 4]

	fmt.Printf("%p\n",s1) //0xc0000601e0
	fmt.Printf("%p\n",s2) //0xc0000601e0
	fmt.Printf("%p\n",&s1) //0xc00005a440
	fmt.Printf("%p\n",&s2) //0xc00005a460
 
}

package main

import "fmt"

func main() {
	/*
	深拷贝：拷贝的是数据本身。
		值类型的数据，默认都是深拷贝：array，int，float，string，bool，struct


	浅拷贝：拷贝的是数据 地址。
		导致多个变量指向同一块内存
		引用类型的数据，默认都是浅拷贝：slice，map，

		因为切片是引用类型的数据，直接拷贝的是地址。

	func copy(dst, src []Type) int
		可以实现切片的拷贝

	 */

	s1 := []int{1,2,3,4}
	//如果make的时候给了len，那么会出现默认值，比如len=3，就是0 0 0
	s2 := make([]int,0) //len:0,cap:0
	for i:=0;i<len(s1);i++{
		s2 = append(s2,s1[i])
	}
	fmt.Println(s1) //[1 2 3 4]
	fmt.Println(s2) //[1 2 3 4]

	s1[0] = 100
	fmt.Println(s1) //[100 2 3 4]
	fmt.Println(s2) //[1 2 3 4]

	//copy()
	s3 := []int{7,8,9}
	fmt.Println(s2) //[1 2 3 4]
	fmt.Println(s3) //[7 8 9]

	//copy(s2,s3) //将s3中的元素，拷贝到s2中
	//copy(s3,s2) //将s2中的元素，拷贝到s3中
	copy(s3[1:],s2[2:])
	fmt.Println(s2) //[1 2 3 4]
	fmt.Println(s3) //[7 3 4]

}