数组可以存放多个同一类型数据。数组也是一种数据类型，在golang中，数组是值类型。
一、数组
1、数组的定义
var 数组名 [数组大小]数据类型
var arr [5]int
2、数组的内存布局
package main
import "fmt"
func main() {
var intArr [3]int
//当定义完数组后，数组的各个元素有默认值0
fmt.Println(intArr)
intArr[0] = 10
intArr[1] = 20
intArr[2] = 30
fmt.Println(intArr)
fmt.Printf("intArr的地址 = %p intArr[0] 地址 = %p intArr[1] 地址 = %p intArr[2] 地址 = %p", &intArr, &intArr[0], &intArr[1], &intArr[2])
}
数组的地址可以通过数组名来获取 &intArr
数组的第一个元素的地址，就是数组的首地址
数组的各个元素的地址间隔是依据数组的类型决定
3、数组的使用
访问数组元素：数组名[下标]
package main
import "fmt"
func main() {
var score [5]float64
for i := 0; i < len(score); i++ {
fmt.Printf("请输入第%d个元素的值
", i+1)
fmt.Scanln(&score[i])
}
for i := 0; i < len(score); i++ {
fmt.Printf("score[%d] = %v
", i, score[i])
}
}
4、四种初始化数组的方式
package main
import "fmt"
func main() {
var numInt [3]int = [3]int{1, 2, 3}
fmt.Println("numInt = ", numInt)
var numFloat = [3]float64{1.0, 9.4, 8.0}
fmt.Println("numFloat = ", numFloat)
var numInt32 = [...]int32{8, 9, 4}
fmt.Println("numInt32 = ", numInt32)
var numInt64 = [...]int64{1: 800, 0: 9000, 2: 899}
fmt.Println("numInt64 = ", numInt64)
strArr := [...]string{2: "mary", 0: "jack", 1: "tom"}
fmt.Println("strArr = ", strArr)
}
5、数组的遍历
(1)、传统方式
package main
import "fmt"
func main() {
var numInt [3]int = [3]int{1, 2, 3}
for i := 0; i < len(numInt); i++ {
fmt.Printf("arr[%v] = %v ", i+1, numInt[i])
}
}
(2)、for - range
package main
import "fmt"
func main() {
var numInt [3]int = [3]int{1, 2, 3}
for index, value := range numInt {
fmt.Printf("arr[%v] = %v ", index, value)
}
heroes := [...]string{"宋江", "吴用", "卢俊义"}
for i, v := range heroes {
fmt.Printf("i = %v v = %v
", i, v)
fmt.Printf("heroes[%d] = %v
", i, heroes[i])
}
for _, v := range heroes {
fmt.Printf("元素的值 = %v
", v)
}
}
第一个返回值index是数组的下标
第二个返回值value是下标位置的值
index和value都是仅在for循环内部可见的局部变量
遍历数组的时候，如果不想使用下标index，可以直接把下标index标为下划线
index和value的名称不是固定的，可以自行定义
6、数组使用的注意事项
(1)、数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化。
(2)、数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。
(3)、数组创建后，如果没有赋值，有默认值。数值类型数组:默认值为0 字符串数组: 默认值为"" bool数组: 默认值为false。
(4)、数组下标必须在指定范围内使用，否则报panic:数组越界。
(5)、go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响。
(6)、如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)。
(7)、长度是数组类型的一部分，在传递函数参数时 需要考虑数组的长度。
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//1、创建一个 byte 类型的 26 个元素的数组，分别 放置'A'-'Z‘。使用 for 循环访问所有元素并打印出来。提示:字符数据运算 'A'+1 -> 'B'
var myChars [26]byte
for i := 0; i < 26; i++ {
myChars[i] = 'A' + byte(i)
}
for i := 0; i < 26; i++ {
fmt.Printf("%c", myChars[i])
}
fmt.Println()
//2、请求出一个数组的最大值，并得到对应的下标。
var intArr [6]int = [...]int{1, -1, 9, 90, 11, 9000}
maxVal := intArr[0]
maxValIndex := 0
for i := 1; i < len(intArr); i++ {
if maxVal < intArr[i] {
maxVal = intArr[i]
maxValIndex = i
}
}
fmt.Printf("maxVal = %v maxValIndex = %v", maxVal, maxValIndex)
//3、请求出一个数组的和和平均值。for-range
var arr [5]int = [...]int{1, -1, 9, 90, 12}
sum := 0
for _, val := range arr {
sum += val
}
fmt.Printf("sum = %v avg = %v
", sum, float64(sum)/float64(len(arr)))
//4、随机生成五个数，并将其反转打印
var randArr [5]int
len := len(randArr)
rand.Seed(time.Now().UnixNano())
for i := 0; i < len; i++ {
randArr[i] = rand.Intn(100)
}
fmt.Println("交换前~=", randArr)
tmp := 0
for i := 0; i < len/2; i++ {
tmp = randArr[len-1-i]
randArr[len-1-i] = randArr[i]
randArr[i] = tmp
}
fmt.Println("交换后~=", randArr)
}
二、切片
切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。
切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样。
切片的长度是可以变化的，因此切片是一个可以动态变化数组。
切片定义的基本语法:var 切片名 []类型 比如:var a [] int
package main
import "fmt"
func main() {
var intArr [5]int = [...]int{1, 22, 33, 66, 99}
slice := intArr[1:3]
fmt.Println("intArr=", intArr)
fmt.Println("slice 的元素是", slice)
fmt.Println("slice 的元素个数", len(slice))
fmt.Println("slice 的容量", cap(slice))
}
slice从底层来说，其实就是一个数据结构(struct结构体)
type slice struct{
ptr *[2]int
len int
cap int
}
1、切片的使用
(1)、定义一个切片，然后让切片去引用一个已经创建好的数组。
package main
import "fmt"
func main() {
var arr [5]int = [...]int{1, 2, 3, 4, 5}
var slice = arr[1:3]
fmt.Println("arr=", arr)
fmt.Println("slice 的元素是", slice)
fmt.Println("slice 的元素个数", len(slice))
fmt.Println("slice 的容量", cap(slice))
}
(2)、通过make创建切片
var 切片名 []type=make([]type,len,[cap])
type就是数据类型；len就是大小；cap指定切片容量，可选，如果分配了cap,则要求cap>=len。
package main
import "fmt"
func main() {
var slice []float64 = make([]float64, 5, 10)
slice[1] = 10
slice[3] = 20
fmt.Println(slice)
fmt.Println("slice size is ", len(slice))
fmt.Println("slice capacity is ", cap(slice))
}
通过make方式创建切片可以指定切片的大小和容量
如果没有给切片的各个元素赋值，那么就会使用默认值
通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素
(3)、定义一个切片直接就指定具体数组，使用原理类似make的方式
package main
import "fmt"
func main() {
var strSlice []string = []string{"tom", "jack", "mary"}
fmt.Println(strSlice)
fmt.Println("strSlice size is ", len(strSlice))
fmt.Println("strSlice capacity is ", cap(strSlice))
}
2、切片的遍历
package main
import "fmt"
func main() {
//传统遍历方式
var arr [5]int = [...]int{10, 20, 30, 40, 50}
slice := arr[1:4]
for i := 0; i < len(slice); i++ {
fmt.Printf("slice[%v] = %v ", i, slice[i])
}
fmt.Println()
//for - range方式遍历切片
for i, v := range slice {
fmt.Printf("slice[%v] = %v
", i, v)
}
}
3、切片使用的注意事项
(1)、切片初始化时 var slice = arr[startIndex:endIndex]
说明:从arr数组下标为startIndex，取到下标为endIndex的元素(不含 arr[endIndex])。
(2)、切片初始化时，仍然不能越界。范围在 [0-len(arr)] 之间，但是可以动态增长.
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[:]
(3)、cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
(4)、切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用
(5)、切片可以继续切片
package main
import "fmt"
func main() {
var arr [5]int = [...]int{10, 20, 30, 40, 50}
slice := arr[1:4]
for i, v := range slice {
fmt.Printf("slice[%v] = %v
", i, v)
}
slice2 := slice[1:2]
slice2[0] = 100 //slice和slice2指向的数据空间是同一个，因此slice2[0]=100,slice[1]=100
fmt.Println("slice2=", slice2)
fmt.Println("slice=", slice)
fmt.Println("arr=", arr)
}
(6)、用 append 内置函数，可以对切片进行动态追加
package main
import "fmt"
func main() {
//用 append 内置函数，可以对切片进行动态追加
var slice []int = []int{100, 200, 300}
slice = append(slice, 400, 500, 600)
fmt.Println("slice ", slice)
slice = append(slice, slice...)
fmt.Println("slice= ", slice)
}
切片append操作的底层原理分析:
切片append操作的本质就是对数组扩容
go底层会创建一下新的数组newArr(安装扩容后大小)将slice原来包含的元素拷贝到新的数组newArr
slice重新引用到newArr
注意newArr是在底层来维护的，程序员不可见
(7)、切片的拷贝操作
package main
import "fmt"
func main() {
var slice []int = []int{1, 2, 3, 4, 5}
var slice2 = make([]int, 10)
copy(slice2, slice)
fmt.Println("slice= ", slice)
fmt.Println("slice2= ", slice2)
var a []int = []int{1, 2, 3, 4, 5}
var sli = make([]int, 1)
fmt.Println(sli)
copy(sli, a)
fmt.Println(sli)
}
copy(para1, para2)参数的数据类型是切片
slice和slice2的数据空间是独立，相互不影响
(8)、切片是引用类型，所以在传递时，遵守引用传递机制。
package main
import "fmt"
func test(slice []int) {
slice[0] = 1000
}
func main() {
var slice []int
var arr [5]int = [...]int{1, 2, 3, 4, 5}
slice = arr[:]
var slice2 = slice
slice2[0] = 10
fmt.Println("slice2 ", slice2)
fmt.Println("slice ", slice)
fmt.Println("arr", arr)
var sli = []int{1, 2, 3, 4}
fmt.Println("sli= ", sli)
test(sli)
fmt.Println("sli= ", sli)
}
4、string和slice
string底层是一个byte数组，因此string也可以进行切片处理
package main
import "fmt"
func main() {
str := "hello@ddd.com"
slice := str[6:]
fmt.Println("slice= ", slice)
}
string和切片在内存的形式，以"abcd"画出内存示意图
string是不可变的，也就说不能通过str[0]='z'方式来修改字符串。如果需要修改字符串，可以先将string -> []byte或者[]rune -> 修改 -> 重写转成string
package main
import "fmt"
func main() {
str := "hello@ddd.com"
arr := []byte(str)
arr[0] = 'z'
str = string(arr)
fmt.Println("str= ", str)
arr2 := []rune(str)
arr2[0] = '北'
str = string(arr2)
fmt.Println("str= ", str)
}
编写一个函数fbn(n int) ,可以接收一个n int,能够将斐波那契的数列放到切片中。
package main
import "fmt"
func fbn(n int) ([]uint64) {
fbnSlice := make([]uint64, n)
fbnSlice[0] = 1
fbnSlice[1] = 1
for i := 2; i < n; i++ {
fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2]
}
return fbnSlice
}
func main() {
fbnSlice := fbn(20)
fmt.Println("fbnSlice= ", fbnSlice)
}