Golang Slice浅析笔记

Slice笔记

源自《Go语言圣经》

数组固定长度，因此在GOlang中使用较少，常使用slice

初始化

数组：

var a [2]int // int类型默认值为0
a := [2]int{1,2} 
a := [2]int{}

name4 := [...]string{"the", "hight"} // ... 暂时不确定长度，等到初始化时候确定

数组的不确定长度，会在初始化的时候确定。都是在编译的时候确定。

slice：

slice就是对数组的切片, 并且a := x[1:9] a 与 x共享内存。切片是对数组的引用。

• 会出现多个slice共享内存的情况，多个slice对数组引用

var a []int
a := []int{}
a := []int{1,2,3}
a := x[1:9]  

//通过元素索引创建：
a := []int{99:1} 

//make创建
a := make([]int, len_a, cap_a)

最后一句：a = [0 0 0 … 1] 创建了一个100个元素的slice， 并且最后一个元素值为1。

遍历：

数组和切片的遍历一样：

for k, v := range ss { // k是索引， v是值
		fmt.Printf("%T , %T", k, v)
	}

数组作为函数参数：

数组指针可以作为函数参数传入。

但是因为数组没有删除、添加数组元素的操作，因此数组用处仍然很少

下面是数组指针的遍历赋值

func zero(ptr *[32]byte) {
	for i := range ptr { //返回的索引值
		ptr[i] = 0
	}
}

slice的本质：

slice 是对数组的底层的地址的拷贝。因此是共享内存的.

对slice的拷贝是对old数组的一个新的slice的别名

下面例子中，修改拷贝的s2，会导致所有的slice and arry都被修改了

a := [4]int{1, 2, 3, 4}
s1 := a[0:3]
s2 := s1
s2[0] = 9
fmt.Println(a, s1, s2) //[9 2 3 4] [9 2 3] [9 2 3]

slice的内存技巧

不借用别的内存的情况下，slice原本内存下实现，旋转、翻转、原有空间修改元素。模拟stack栈等

将后面的元素全部前移：

使用copy()函数实现一整块元素的覆盖

copy(slice[i:],slice[i+1:]) // i元素被覆盖，所有i后面的元素前移

reverse反转slice

[8 7 6 5 4 3 2 1] 将全部前后元素兑换位子

slice切片实现：

func reverse(s []int) {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
}

数组指针实现

func reverse(par *[8]int) [8]int {
	for i := range par[0:4] { //只进行一半
		par[i], par[len(par)-i-1] = par[len(par)-i-1], par[i]
	}
	return *par
}
//[8 7 6 5 4 3 2 1]

整体移动n元素

一种将slice元素循环向左旋转n个元素（类似一个圈）

0, 1, 2, 3, 4, 5 - > 2 3 4 5 0 1

// 左旋n个位子
func rotate(s []int, n int) []int {
	if n > len(s) {
		fmt.Print("n < len  Please!")
		return nil
	}

	//赋值s到一个大的slice中
	slen := len(s)
	temp := make([]int, 2*slen)
	copy(temp, s)
	fmt.Println(temp, "   ", s, cap(temp))

	// 将最前面的元素放到最末尾去，再返回有元素的部分的slice
	i := 0
	for ; i < n; i++ {
		temp[slen+i] = temp[i]
	}
	return temp[i : slen+i]
}
// [2 3 4 5 0 1]

原地完成消除[]string中相邻重复的字符串的操作。

// 从最后面开始(减少移动)
// i 与 i -1个元素比较，如果重复则覆盖i元素，后面全部元素前进一个位子
func deleteSame(s []string) []string {
	lens := len(s)
	for i := lens - 1; i > 0; i-- {
		if s[i-1] == s[i] {
			//往前覆盖一个位子
			copy(s[i:], s[i+1:])
			lens-- //挪动元素之后，原本slice的元素还留在原来的空间
		}
	}
	return s[:lens]
}