golang基础---Slice切片

切片Slice在go语言中是单独的类型（指向底层的数组），不同于python(对可迭代对象操作的工具)，注意区分数组和slice的区别

定义一个空slice,格式var s []int,这种既没有长度也没有元素赋值的类型（相比叫array）

数组的基本操作如下，类似与python中列表切片的操作，详见实例

package main

import "fmt"

func main() {

	var s1 []int                                //这样就是一个slice类型，既没有长度也没有元素赋值

	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //这是一个数组

	s2 := a[5:10]                               //切片，索引5到10的元素，不包含索引为10

	s3 := a[:3]                                 //切片，索引1-3的元素，不包含索引3

	s4 := a[6:]                                 //切片，第6个索引到最后一个索引的元素

	s5 := a[:]                                  //切片，复制一个数组

	fmt.Println(s1)

	fmt.Println(a)

	fmt.Println(s2) //数组的切片，类似python

	fmt.Println(s3)

	fmt.Println(s4)

	fmt.Println(s5)

}

/*输出

s1--->  []

a--->   [0 0 0 0 0 0 0 0 0 0]

s2--->  [6 7 8 9 10]

s3--->	[1 2 3]

s4--->	[7 8 9 10]

s5--->	[1 2 3 4 5 6 7 8 9 10]

*/

使用make初始化一个slice类型，包含三个参数

①切片类型 []int
②初始长度 len

③容量 cap

package main

import "fmt"

func main() {

	s1 := make([]int, 3, 10)      //使用make初始化一个slice,包含三个参数：①切片类型②初始长度③容量

	fmt.Println(len(s1), cap(s1)) //输出长度，容量

	fmt.Println(s1)

}

/*输出：

len(s1)--->3

cap(s1)--->10

s1--->	[0 0 0]  //可变数组

*/

Reslice ,在原slice基础上再次切片，slice一个数组时，不仅取出了len,同时容量也会得到相应的切片。

示例

//Reslice,在slice基础上再次slice.

package main

import "fmt"

func main() {

	a := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'k', 'm'} //定义一个数组，元素为byte类型

	sa := a[3:5]                                             // slice切片，取索引三到五，不包含索引5

	sb := sa[1:3]

	fmt.Println(string(sa))

	fmt.Println(len(sa), cap(sa))

	fmt.Println(string(sb))

	fmt.Println(len(sb), cap(sb))

}

/*输出

sting(sa)--->	de

len(sa)--->		2

cap(sa)--->		6

string(sb)--->  ef

len(sb)--->		2

cap(sb)--->		5

*/

Append,类似python中list类型，使用append,从数组尾部追加元素

可以将一个slice追加在另一个slice尾部
如果最终长度未超过追加到slice的容量，则返回原始slice

如果超过追加的slice的容量则将重新分配数组并拷贝原始数据

package main

import "fmt"

func main() {

	s1 := make([]int, 3, 8) //初始化slice,长度位3，容量为8

	fmt.Printf("%p\n", s1)  //输出s1的内存地址

	fmt.Println(s1)

	s1 = append(s1, 1, 2, 3) //末尾追加三个元素,cap依然为8

	fmt.Printf("%p\n", s1)   //原来的slice

	fmt.Println(s1)

	s1 = append(s1, 1, 2, 3, 4) //继续追加元素，超过原s1容量，会重新分配新的内存地址

	fmt.Printf("%p\n", s1)      //cap容量超过8，为9

	fmt.Println(s1)

}

/*

p*s1---> 	0xc042070040

s1--->	 	[0 0 0]

p*s1s1-->	0xc042070040

s1--->	    [0 0 0 1 2 3]

p*s1--->	0xc04205e080   //新的内存地址

s1--->		[0 0 0 1 2 3 1 2 3 4]

*/

当两个slice同时指向某一个数组时，改变某一个slice索引时，另一个slice索引值及原数组的索引也会改变

package main

import "fmt"

func main() {

	a := []int{1, 2, 3, 4, 5, 6}

	s1 := a[2:5]

	s2 := a[1:3]

	fmt.Println(s1, s2)

	s1[0] = 9

	fmt.Println(s1, s2)

	fmt.Println(a)

}

/*

s1--->	[3 4 5]

s2--->	[2 3]

//更改s1的slice索引后，s2的索引也会改

s1--->	[9 4 5]

s2--->	[2 9]

a--->	[1 2 9 4 5 6]

*/

copy，格式 copy(s1,s2), 将s2拷贝到s1数组中，当len(s1) > len(s2)时，最终将s2中的索引

替换掉s1的索引，当len(s1)<len(s2)时，s1的索引值全部被对应s2的索引替换

示例

package main

import "fmt"

func main() {

	s1 := []int{1, 2, 3, 4, 5}

	s2 := []int{6, 7, 8}

	copy(s1, s2) //将s2的元素拷贝到s1,s2

	fmt.Println(s1)

	copy(s2, s1)

	fmt.Println(s2)

	copy(s1, s2[2:3]) //只拷贝某一切片的索引

	fmt.Println(s1)

}

/*输出

s1--->	[6 7 8 4 5]

s2--->	[1 2 3]

s1--->	[8 2 3 4 5]

*/

巴特西

golang基础---Slice切片

最新文章

热门文章