Go语言实战之数组的内部实现和基础功能
写在前面
嗯，学习 ，所以有了这篇文章博文内容为 读书笔记之一主要涉及GO学习环境配置数组相关知识
GO学习环境配置
┌──[root@liruilongs.github.io]-[/]
└─$ rm -rf /usr/local/go && tar -C /usr/local -xzf go1.17.7.linux-amd64.tar.gz
┌──[root@liruilongs.github.io]-[/]
└─$ export PATH=$PATH:/usr/local/go/bin
┌──[root@liruilongs.github.io]-[/]
└─$ go version
go version go1.17.7 linux/amd64
┌──[root@liruilongs.github.io]-[/]
└─$
数组的内部实现和基础功能
是一种数据结构。它用一组的，来存储一组具有。
内部实现
数组结构上 ，所以很容易的(元素的相对地址)，，同时，可以很好的使用，当访问时，会自动的，加载多少由决定，所以能把正在使用的数据缓存更久的时间。当内存不连续时，就无法读到 ，只能重复的从内存读取数据元素，也就不能充分利用到了的特性通过索引可以快速的迭代数组元素，如果用a代表数组的首地址， 就是偏移量为的位置，也就是首地址，就表示偏移量个的位置，所以计算的内存地址只需要用这个公式,所以说可以通过索引确认内存地址快速迭代,理论上时间复制度为常量级。
声明和初始化
时需要指定内部存储的数据的，以及需要存储的元素的
声明一个数组，并设置为零值
var arrays [5]int
使用数组字面量声明数组
arrays := [5]int{10,12,13}
让 自动计算声明数组的长度
array := [...]int{10, 20,30, 40, 50}
声明数组并指定特定元素的值,用具体值初始化索引为 和的元素
array := [5]int{1: 10, 2: 20}
使用数组
访问数组元素
//声明一个包含 5 个元素的整型数组
array := [5]int{10, 20, 30, 40, 50}
// 修改索引为 2 的元素的值
array[2] = 35
。使用就可以访问元素指针所指向的值
访问指针数组的元素
// 声明包含 5 个元素的指向整数的数组
// 用整型指针初始化索引为 0 和 1 的数组元素
array := [5]*int{0: new(int), 1: new(int)}
// 为索引为 0 和 1 的元素赋值
*array[0] = 10
*array[1] = 20
// 声明第一个包含 5 个元素的字符串数组
var array1 [5]string
// 声明第二个包含 5 个元素的字符串数组
// 用颜色初始化数组
array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}
// 把 array2 的值复制到 array1
array1 = array2
编译器会阻止类型不同的数组互相赋值
package main
import "fmt"
func main() {
fmt.Println("你好，世界")
// 声明第一个包含 4 个元素的字符串数组
var array1 [4]string
// 声明第二个包含 5 个元素的字符串数组
// 使用颜色初始化数组
array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}
// 将 array2 复制给 array1
array1 = array2
}
检查
┌──[root@liruilongs.github.io]-[/usr/local/go/src/demo]
└─$go fmt array.go
array.go
┌──[root@liruilongs.github.io]-[/usr/local/go/src/demo]
└─$vim array.go
┌──[root@liruilongs.github.io]-[/usr/local/go/src/demo]
└─$go vet array.go
# command-line-arguments
vet: ./array.go:15:11: cannot use array2 (variable of type [5]string) as [4]string value in assignment
┌──[root@liruilongs.github.io]-[/usr/local/go/src/demo]
└─$
多维数组
声明二维数组
// 声明一个二维整型数组，两个维度分别存储 4 个元素和 2 个元素
var array [4][2]int
// 使用数组字面量来声明并初始化一个二维整型数组
array := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}
// 声明并初始化外层数组中索引为 1 个和 3 的元素
array := [4][2]int{1: {20, 21}, 3: {40, 41}}
// 声明并初始化外层数组和内层数组的单个元素
array := [4][2]int{1: {0: 20}, 3: {1: 41}}
访问二维数组的元素
// 声明一个 2×2 的二维整型数组
var array [2][2]int
// 设置每个元素的整型值
array[0][0] = 10
// 声明两个不同的二维整型数组
var array1 [2][2]int
var array2 [2][2]int
// 为每个元素赋值
array2[0][0] = 10
array2[0][1] = 20
array2[1][0] = 30
array2[1][1] = 40
同样类型的多维数组赋值
// 将 array2 的值复制给 array1
array1 = array2
使用索引为多维数组赋值
// 将 array1 的索引为 1 的维度复制到一个同类型的新数组里
var array3 [2]int = array1[1]
// 将外层数组的索引为 1、内层数组的索引为 0 的整型值复制到新的整型变量里
var value int = array1[1][0]
在函数间传递数组
使用值传递，在函数间传递大数组
// 声明一个需要 8 MB 的数组,创建一个包含 100 万个 int 类型元素的数组
var array [1e6]int
// 将数组传递给函数 foo
foo(array)
// 函数 foo 接受一个 100 万个整型值的数组
func foo(array [1e6]int) {
...
}
使用指针在函数间传递大数组
// 分配一个需要 8 MB 的数组
var array [1e6]int
// 将数组的地址传递给函数 foo
foo(&array)
// 函数 foo 接受一个指向 100 万个整型值的数组的指针
func foo(array *[1e6]int) {
...
}