代码示例
package main
import "fmt"
func main(){
fmt.Println("Hello, world")
// 定义数组的常规方法
/******************************
[32]byte // 长度为32的数组
[2 * N] struct {x, y int32} // 复杂类型数组
[100]*float32 // 指针数组
[2][3]int // 二维数组
[2][2][2] float64 // 等同于[2] ([2] ([2] float64))
******************************/
array := [5]int{1,2,3,4,5}
// 遍历数组
fmt.Println("Traverse func 1 --->")
for i:= 0; i < len(array); i++ {
fmt.Printf("%d\t",array[i])
}
fmt.Println()
for i, v := range array {
fmt.Printf("index %d is %d\n", i, v)
}
// try to use modify func to modify array
// cannot success, value type
modifyArray(array)
fmt.Println("In main func(), array values -->", array)
// use slice
useSlice()
}
// 数组是值类型
func modifyArray(array [5]int){
array[0] = 12
fmt.Println("In Modify func(), array values -->", array)
}
// 数组切片的结构定义
// 一个指向原生数组的指针
// 数据切片的元素个数
// 数组切片已分配的存储空间
func useSlice(){
// 1. 创建数组切片
// 基于数组
var myArr [3]int32 = [3]int32{23,1,3}
// myArray[first:last]
var mySlice []int32 = myArr[:]
fmt.Println("Elements of myArr is")
for _, v := range myArr {
fmt.Printf("%d\t", v)
}
fmt.Println()
fmt.Println("\nElement of mySlice is ")
for _, v := range mySlice {
fmt.Printf("%d\t", v)
}
fmt.Println()
// 2. 直接创建
fmt.Println("直接创建数组切片")
// 创建一初始元素个数为5，初始值为0，预留10个元素的存储空间的slice
mySliceOne := make([]int, 5, 10)
fmt.Println("\nmySliceOne is ", mySliceOne)
// 创建并且初始化包含5个元素的数组切片
mySliceTwo := []int{1,2,3,43,23}
fmt.Println("\nmySliceTwo is ", mySliceTwo)
// 3. 遍历数组切片
for _, v := range mySliceTwo {
fmt.Printf("%d\t", v)
}
// 4. 动态增减元素
// go语言内置cap和len两个函数
// cap返回的是数组切片的分配的空间大小,len返回的屙屎数组切片中当前所存储的元素个数
myNewSlice := make([]int, 5, 10)
fmt.Println("myNewSlice is ", myNewSlice)
fmt.Println("len(myNewSlice) is ", len(myNewSlice))
fmt.Println("cap(myNewSlice) is ",cap(myNewSlice))
// 5. 如果需要继续在myNewSlice中添加3个元素,使用append方法
myNewSlice = append(myNewSlice, 12, 12 , 23)
fmt.Println("after append 5 elements in slice, results is ", myNewSlice)
// append后面的参数其实是不定参数, 也可以直接将一个slice添加到一个slice中，只是写法会有些不一样
subSlice := []int{12,2,1}
// 注意第二个参数后面的三个点
// 数组切片会自动处理内存空间不足的问题，如果内存不够，就会自动分配一块够大的空间
myNewSlice = append(myNewSlice, subSlice...)
fmt.Println("after append other slice in slice, results is ", myNewSlice)
// 6. 基于数组切片创建数组切片
oldSlice := []int{12,23,12}
newSlice := oldSlice[1:2]
fmt.Println("newSlice is ", newSlice)
// 7. 内容复制
// copy内置函数,如果两个数组切片不一样大，则按照其中个数少的那个进行复制
s1 := []int{1,2,34,4,5,6}
s2 := []int{4,21,1}
// 只复制s1的前3个元素到s2中
fmt.Println("\ns2 is ", s2)
copy(s2, s1)
fmt.Println("copy elements of s1 to s2 is ", s2)
// 只复制s2的3个元素到s2的前3个元素中
fmt.Println("\ns1 is ", s1)
copy(s1, s2)
fmt.Println("copy elements of s2 to s1 is ", s1)
}
输出结果
Hello, world
Traverse func 1 --->
1 2 3 4 5
index 0 is 1
index 1 is 2
index 2 is 3
index 3 is 4
index 4 is 5
In Modify func(), array values --> [12 2 3 4 5]
In main func(), array values --> [1 2 3 4 5]
Elements of myArr is
23 1 3
Element of mySlice is
23 1 3
直接创建数组切片
mySliceOne is [0 0 0 0 0]
mySliceTwo is [1 2 3 43 23]
1 2 3 43 23 myNewSlice is [0 0 0 0 0]
len(myNewSlice) is 5
cap(myNewSlice) is 10
after append 5 elements in slice, results is [0 0 0 0 0 12 12 23]
after append other slice in slice, results is [0 0 0 0 0 12 12 23 12 2 1]
newSlice is [23]
s2 is [4 21 1]
copy elements of s1 to s2 is [1 2 34]
s1 is [1 2 34 4 5 6]
copy elements of s2 to s1 is [1 2 34 4 5 6]
