码迷,mamicode.com
首页 > 其他好文 > 详细

Go切片

时间:2020-02-01 11:06:30      阅读:101      评论:0      收藏:0      [点我收藏+]

标签:runtime   print   类型   fun   main   port   超过   ++   内容   

1. 切片的创建和使用

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)
	}

}

2. 切片是引用了底层数组

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)
}

3. slice := arr[start:end]

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
}

4. 数组是引用类型

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
 
}

5. 深拷贝和浅拷贝

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]

}

 

Go切片

标签:runtime   print   类型   fun   main   port   超过   ++   内容   

原文地址:https://www.cnblogs.com/yzg-14/p/12247478.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!