数组与切片

数组的声明

func TestArrayList(t *testing.T)  {
   
	//数组的声明

	//声明并初始化为默认0值
	var a [3]int
	a[0] = 1
	t.Log(a[1],a[2])

	//声明同时初始化
	b := [3]int{
   1,2,3}
	//自动初始化到后面元素个数的长度
	c := [...]int{
   1,2,3,4,5}
	//多维数组初始化
	d := [2][2]int{
   {
   1,2},{
   3,4}}
	t.Log(b[0],c[1],d[1][1])
}

数组的遍历

//数组的遍历
func TestArrayTrave(t *testing.T){
   
	arrList := [...]int{
   1,2,3,4,5,6,7,8,9,0}
	for i:=0;i<len(arrList);i++{
   
		t.Log(arrList[i])
	}
	//for each idx索引 e数值
	//同_标识并不关心这个值的结果，可以定义不使用不报错
	for idx, e:= range arrList{
   
		t.Log(idx,e)
	}

	//数组截取
	t.Log(arrList[1:])
}

切片 初始化

	//a[start:end]	包含:不包含 不支持负数
	//切片的内部结构 用起来像一个可变长的数组
	//内部是一个结构体，1.指针（指向一片连续的存储空间）2.len（可以访问的元素的个数）3.（指向的数组后台空间的长度）
	
func TestSliceInit(t *testing.T){
   
	//切片和数据的区别 切片不用设置长度 且有底层数据结构
	//切片 共享的存储结构
	//几个切片共享一块内存

	//初始化方法一
	var s0 []int
	// 0 0
	t.Log(len(s0),cap(s0))
	s0 = append(s0, 1)

	//初始化方法二
	s1 := []int{
   1,2,3,4}
	t.Log(len(s1),cap(s1))

	//初始化方法三
	//*[]type len cap 长度是3 容量是5
	s2 := make([]int,3,5)
	t.Log(len(s2),cap(s2))
	//访问len以外 cap之内的元素会报错
	//len 可访问元素的个数 cap 容量
	t.Log(s2[0],s2[1],s2[2])
	//添加一个元素之后，len+1 但是 容量cap不变
}

实现切片和可变长

//实现切片可变长
func TestSliceGrowing(t *testing.T){
   
	s := []int {
   }
	for i:=0;i<5;i++{
   
		//指向的连续存储空间的地址发生了变化，扩容时会发生深拷贝
		//自增长需要更多的代价
		s = append(s,i)
	}
	//放入元素超过原有元素就会扩容 cap内存不够了就二倍扩容1/2/4/8/16
}

切片共享内存的副作用

func TestSliceShareMemory(t *testing.T){
   
	year := []string{
   "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}
	Q2 := year[3:6]
	//切片的长度是从截取部分一直到数组结束
	t.Log(Q2,len(Q2),cap(Q2))
	//共享了同一个后端数组，无论被谁修改，都会影响到所有的使用者
	//切片本身是一个结构体，有一个指针指向了后端连续的存储空间
	//两个切片共享一个后端数组，一个改变了后端数据会影响另外一个，
	Q3 := year[5:8]
	Q3[0] = "Useless"
	t.Log(Q2)
}

数组和切片的区别

//数组和切片的区别
/*
	1.容量是否可以伸缩
		数组不可伸缩
		切片可以伸缩
	2.是否可以进行比较
		数组 相同长度元素，相同元素的数组可以比较
*/


//切片的比较
func TestSliceComparing(t testing.T)  {
   
	a:=[]int{
   1,2,3,4}
	b:=[]int{
   1,2,3,4}
	//切片只能和空nil比较，不能和切片比较
	if a == b {
   
		t.Log("success")
	}
}