5.Go语言基础-数组切片

数组

数组就是指一系列同一类型数据的集合,值类型

数组定义:var arr [n]type


func TestArray(t *testing.T) {
	//定义固定长度数组
	arr := [3]int{1, 2, 3}
	//循环
	for index, val := range arr {
		t.Log(index, val)
	}

    //获取数组长度
    arrlen := len(arr)
    
   
    //元素访问
	fmt.Println(arr[2])

	//定义非固定长度数组
	b := [...]int{2, 3, 4, 4, 5}
	//数组截取前三个元素
	c := b[:3]
	t.Log(c)
}

切片

引用类型，内部结构是一个结构体，ptr是一个指针，len是可以访问的元素的个数，cap指针指向的空间的长度

func TestSlice(t *testing.T) {
	//切片初始化
	var s1 []int
	t.Log(s1, len(s1), cap(s1)) //[] 0 0
	s1 = append(s1, 1)
	t.Log(s1, len(s1), cap(s1)) //[1] 1 1

	var s2 = []int{2, 3, 4, 5, 6}
	t.Log(len(s2), cap(s2)) //5 5

	s3 := make([]int, 3, 5)
	t.Log(len(s3), cap(s3))           //3 5
	t.Log(s3[0], s3[1], s3[2], s3[3]) //panic: runtime error: index out of range [3] with length 3 [recovered],此处可以看出len 和cap的区别
	s3 = append(s3, 1)
	t.Log(s3[0], s3[1], s3[2], s3[3]) // 0 0 0 1
}

//放入的元素超过存储空间的时候，容量成倍增长
func TestSliceGrowing(t *testing.T) {
	s := []int{}
	for i := 0; i < 10; i++ {
		s = append(s, i)
		t.Log(len(s), cap(s))
		//运行结果
		//5数组切片_test.go:46: 1 1
		//5数组切片_test.go:46: 2 2
		//5数组切片_test.go:46: 3 4
		//5数组切片_test.go:46: 4 4
		//5数组切片_test.go:46: 5 8
		//5数组切片_test.go:46: 6 8
		//5数组切片_test.go:46: 7 8
		//5数组切片_test.go:46: 8 8
		//5数组切片_test.go:46: 9 16
		//5数组切片_test.go:46: 10 16
	}
}

//不同切片占用一个存储空间,无论对一块存储空间修改，都会修改
func TestSliceShareMemory(t *testing.T) {
	var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8}
	s2 := s1[3:6]
	t.Log(s2, len(s2), cap(s2)) //运行结果 [4 5 6] 3 5

	s3 := s1[4:6]
	t.Log(s3, len(s3), cap(s3)) //运行结果 [5 6] 2 4

	s3[0] = 100
	t.Log(s2) //运行结果：[4 100 6]  s3的第一个元素和s2第二个元素共用了一块内存空间，所以修改s3 s2的值同时变化
}

总结数据和切片的不同点：

        1.数组容量不可伸缩，切片容量可伸缩

        2.数据可比较，切片不可比较