Go数组与切片

Go数组与切片

数组

package main
import(
	"fmt"
)
func main(){
	//数组的定义
	/*
	var 数组名 [数组大小]数据类型
	*/

	var intArr [3]int
	//定义完数组后，数组的各个元素都有默认值0
	fmt.Println(intArr)//[0 0 0]

	//数组的地址可以通过数组名来获取&intArr
	//数组第一个元素的地址就是数组的首地址
	//数组的各个元素的地址间隔是由数组类型决定

	//初始化数组
	var numArr01 [3]int = [3]int{1,2,3}
	fmt.Println("numArr01=",numArr01)

	var numArr02 = [3]int{5,6,7}
	fmt.Println("numArr02=",numArr02)

	//[...]是规定的写法
	var numArr03 = [...]int{8,9,10}
	fmt.Println("numArr03=",numArr03)

	var numArr04 = [...]int{1:800,0:900,2:999}
	fmt.Println("numArr04=",numArr04)

	//类型推导
	strArr05 := [...]string{1:"tom",2:"mary",0:"jack"}
	fmt.Println("strArr05=",strArr05)

	//Go的数组属于值类型，在默认情况下是值传递，会进行值拷贝，数组间不会影响
}

切片

package main
import(
	"fmt"
)

//切片slice
//切片是数组的一个引用，切片是引用类型
//切片的长度是可以变化的1，切片是一个动态变化数组
//基本语法
/*
var 切片名 []类型
*/

func main(){
	var intArr [5]int = [...]int{1,22,33,66,99}
	//声明/定义一个切片
	//slice := intArr[1:3]
	//slice为切片名
	//intArr[1：3]表示slice引用到intArr这个数组
    //修改slice也会修改intArr
	//引用intArr数组的起始下标为1，最后下标为3（不包含3)
	slice := intArr[1:3]
	fmt.Println("intArr=",intArr)
	fmt.Println("slice的元素=",slice)
	fmt.Println("slice的元素个数=",len(slice))
	fmt.Println("slice的容量=",cap(slice))//切片的容量是可以动态变化的

	//slice从底层看是一个结构体
	/*
	type slice struct {
		ptr *[2]int
		len int
		cap int
	}
	*/

	//切片的使用
	//方式一
	//定义一个切片，让切片引用一个已经创建好的数组

	//方式二
	//通过make创建切片
	//基本语法
	//var 切片名 []type = make([],len,[cap])
	var slice1 []float64 
	slice1 = make([]float64,5,10)
	slice[3] = 10
	slice [0] =20
	//没赋值的默认为0
	//slice必须make使用
	fmt.Println(slice1)
	fmt.Println("slice1 size=",len(slice1))
	fmt.Println("slice1 cap=",cap(slice1))
	//通过make方式创建的切片对于的数组是由make底层维护的，对外不可见
	//只能通过slice去访问各个元素

	//方式三
	//定义一个切片，直接就指定具体数组，使用原理类似make
	var strSlice []string = []string{"tom","jack","mary"}
	fmt.Println(strSlice)
	fmt.Println(len(strSlice))
	fmt.Println(cap(strSlice))

	//切片初始化是不能越界，但可以动态增长
	//var slice = arr[0:end] 等同于 var slice = arr[:end]
	//var slice = arr [start:len(arr)]等同于 var slice = arr[start:]
	//var slice = arr [0:len(arr)] 等同于 var slice = arr [:]

	//切片可以继续切片
	var arr01 [5]int = [...]int {10,20,30,40,50}
	slice01 := arr [1:4]
	slice02 := slice01[1:2]
	//因为arr01,slice01和slice02指向的数据空间是同一个

	//用append内置函数，可以对切片进行动态追加
	var slice3 []int = []int{100,200,300}
	//通过append直接给slice3追加具体的元素
	slice3 = append(slice3,400,500,600)
	fmt.Println("slice3",slice3)
	//通过append将切片slice3追加给slice3
	slice3 = append(slice3,slice3...)
	fmt.Println("slice3",slice3)
	//append底层原理
	//go底层会创建一些新的数组newArr
	//将原来包含的元素拷贝到新的数组
    //slice与原数组没有关系了
	//slice重新引用到newArr
	//newArr是在底层维护的，程序员看不到

	//切片的拷贝操作
	//切片使用copy内置函数完成拷贝
	fmt.Println()
	var slice4 []int = []int {1,2,3,4,5}
	var slice5 = make([]int,10)//10为容量
	copy(slice5,slice4)
	fmt.Println("slice4",slice4)
	fmt.Println("slice5",slice5)

	//string是不可变的，不可以通过下标修改
	//如果需要修改字符串，可以转换为切片
	str := "hello@atguigu"
	//若有汉字则为[]rune
	arr01 := []byte(str)
	arr01[0] = 'z'
	str = string(arr01)//重新转为字符串
	fmt.Println("str=",str)

	
}