GO切片数组

数组

1、数组是值类型

2、长度必须确定，大小不可改变

3、能多类型混合,[size]any 也是类型

4、[…]any，定长的，看数组元素个数多少…就是多少

5、二维数组可以有 […] [ii]的写法

package main

import "fmt"

//数组的特点
//1、长度必须确定，大小不可改变
//2、不能多类型混合,[size]any 也是类型

func main() {
	//定义数组
	var arr1 [5]int

	//给数组赋值
	//数组下标从0零开始
	arr1[0] = 100
	arr1[1] = 200
	arr1[2] = 300
	arr1[3] = 400
	arr1[4] = 500

	fmt.Println(arr1)

	fmt.Println(arr1[1])

	//len() 取数组长度   cap() 取数组容量
	fmt.Println("长度", len(arr1))
	fmt.Println("容量", cap(arr1))
}

package main

import "fmt"

func main() {
	var arr01 [5]int
	arr01[0] = 100
	fmt.Println(arr01)

	var arr02 = [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr02)

	//快速初始化 :=
	arr03 := [5]int{1, 3, 5, 7, 9}
	fmt.Println(arr03)

	//长度不确定的数组
	//[...]是固定的大小，取决于数组中元素个数
	var arr04 = [...]int{1, 2, 3, 3, 3, 3, 3, 3, 3, 5, 6}
	fmt.Println(arr04)

	var arr05 [10]int
	fmt.Println(arr05)
	arr05 = [10]int{1: 100, 5: 500, 7: 700}
	fmt.Println(arr05)
}

遍历数组元素

package main

import "fmt"

func main() {
	var arr1 = [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr1[0])
	fmt.Println(arr1[1])
	fmt.Println(arr1[2])
	fmt.Println(arr1[3])
	fmt.Println(arr1[4])

	fmt.Println("----------")
	//获取长度 len()
	for i := 0; i < len(arr1); i++ {
		fmt.Println(arr1[i])
	}
	fmt.Println("-----------")
	// for index,value  range 目标数组切片
	for index, value := range arr1 {
		fmt.Println("i", index, "v", value)
	}
}

数组的排序

//升序 ASC    从小到大
//降序 DESC   从大到小 

package main

import "fmt"

//数组是值类型
func main() {
	var arr1 = [...]int{96, 56, 91, 22, 38, 58, 68}
	for i := 1; i < len(arr1); i++ {
		for j := 0; j < len(arr1)-1; j++ {
			if arr1[j] < arr1[j+1] {
				arr1[j], arr1[j+1] = arr1[j+1], arr1[j]
			}
		}
		fmt.Println(arr1)
	}
}

多维数组

package main

import "fmt"

func main() {

	//定义二维数组
	arr := [3][5]int{
		{0, 1, 2, 3, 4},
		{5, 6, 7, 8, 9},
		{10, 11, 12, 13, 14},
	}
	fmt.Println(arr[0][2])
	fmt.Println(arr[2])
	fmt.Println("==========")
	//遍历二维数组
	for i := 0; i < len(arr); i++ {
		fmt.Println(arr[i])
	}

	for i, v := range arr {
		fmt.Println(i, v)
	}
}

切片：对数组的一个抽象Slice

1、切片是对数组的抽象

2、切片长度不固定，可追加元素，追加时可使切片容量增大

3、切片是对数组的引用

4、切片是引用类型

1、每个切片引用一个底层数组

2、向切片中增加数据时，如果没有超过切片容量，直接添加，如果超过容量，就会自动扩容，copy

3、切片一旦扩容就是指向一个新的数组

package main

import "fmt"

func main() {
	var arr = [3]int{1, 2, 3}

	//切片
	var s1 []int
	fmt.Println(s1)

	s2 := []int{1, 2, 3, 4} //切片变长
	fmt.Println(s2)
	fmt.Printf("%T,%T\n", arr, s2)
}

切片的扩容

package main

import "fmt"

func main() {
	s1 := make([]int, 0, 5) //长度,容量
	fmt.Println(s1)

	//切片的扩容
	s1 = append(s1, 1, 2)
	fmt.Println(s1)

	s2 := []int{100, 200, 300}
	s1 = append(s1, s2...)
	fmt.Println(s1)

	//遍历切片
	for i := range s1 {
		fmt.Println(s1[i])
	}
}

1、cap是每次成倍增加的

2、只要容量扩容了，地址就会发生变化