数组底层

1. 数组

数组，定长且元素类型一致的数据集合。

// 方式一：先声明再赋值（声明时内存中已开辟空间，内存初始化的值是0）
var numbers [3]int
numbers[0] = 999
numbers[1] = 666
numbers[2] = 333

// 方式二：声明+赋值
var names = [2]string{"武沛齐","alex"}

// 方式三：声明+赋值 + 指定位置
var ages = [3]int{0:87,1:73,2:99}

// 方式四：省略个数
var names = [...]string{"武沛齐","alex"}
var ages = [...]int{  0:87,  2:99 }

// 声明 指针类型的数组（指针类型），不会开辟内存初始化数组中的值，numbers = nil
var numbers *[3]int

// 声明数组并初始化，返回的是 指针类型的数组（指针类型）
numbers := new([3]int)

1.1. 数组内存管理

数组，定长且元素类型一致的数据集合。

必备知识点：

• 数组的内存是连续的。
• 数组的内存地址实际上就是数组第一个元素的内存地址。

• 每个字符串的内部存储：len + str

  type stringStruct struct {
      str unsafe.Pointer
      len int
  }
  

示例1：int8 16进制每次+1

package main

import "fmt"

func main() {
    nums := [3]int8{11, 22, 33}

    fmt.Printf("数组的内存地址：%p \n", &nums)
    fmt.Printf("数组第1个元素的内存地址：%p \n", &nums[0])
    fmt.Printf("数组第2个元素的内存地址：%p \n", &nums[1])
    fmt.Printf("数组第3个元素的内存地址：%p \n", &nums[2])
}

>>> 输出
数组的内存地址：0xc00001604a 
数组第1个元素的内存地址：0xc00001604a 
数组第2个元素的内存地址：0xc00001604b 
数组第3个元素的内存地址：0xc00001604c

示例2：16进制每次+4

package main

import "fmt"

func main() {
    nums := [3]int32{11, 22, 33}

    fmt.Printf("数组的内存地址：%p \n", &nums)
    fmt.Printf("数组第1个元素的内存地址：%p \n", &nums[0])
    fmt.Printf("数组第2个元素的内存地址：%p \n", &nums[1])
    fmt.Printf("数组第3个元素的内存地址：%p \n", &nums[2])
}

>>> 输出
数组的内存地址：0xc0000b4004 
数组第1个元素的内存地址：0xc0000b4004 
数组第2个元素的内存地址：0xc0000b4008 
数组第3个元素的内存地址：0xc0000b400c

示例3：16进制每次+16

package main

import "fmt"

func main() {
    names := [2]string{"武沛齐", "alex"}
    fmt.Printf("数组的内存地址：%p \n", &names)
    fmt.Printf("数组第1个元素的内存地址：%p \n", &names[0])
    fmt.Printf("数组第2个元素的内存地址：%p \n", &names[1])

}

>>> 输出：
数组的内存地址：0xc000128020 
数组第1个元素的内存地址：0xc000128020 
数组第2个元素的内存地址：0xc000128030

1.2. 可变和拷贝

可变，数组的元素可以被更改（长度和类型都不可以修改）。

names := [2]string{"武沛齐", "alex"}
names[1] = "苑昊"

注意：字符串不可以被修改。 "武沛齐" "武陪齐"

拷贝，变量赋值时重新拷贝一份。

name1 := [2]string{"武沛齐", "alex"}
name2 := name1

name1[1] = "苑昊"

fmt.Println(name1,name2)   // [武沛齐 苑昊]   [武沛齐 alex]

1.3. 长度索引切片和循环

package main

import "fmt"

func main() {
    // 1. 长度
    //name := [2]string{"武沛齐", "alex"}
    //fmt.Println(len(name))

    // 2. 索引
    //name := [2]string{"武沛齐", "alex"}
    //data := name[0]
    //fmt.Println(data)
    //name[0] = "eric"
    //fmt.Println(name)

    // 3. 切片
    //nums := [3]int32{11, 22, 33}
    //data := nums[0:2] // 获取   0 <= 下标 < 2
    //fmt.Println(data)

    // 4. 循环
    //nums := [3]int32{11, 22, 33}
    //for i:=0;i<len(nums);i++{
    //    fmt.Println(i, nums[i] )
    //}

    // 5.for range 循环
    nums := [3]int32{11, 22, 33}
    for key, item := range nums {
        fmt.Println(key, item)
    }

    for key := range nums {
        fmt.Println(key)
    }

    for _,item := range nums {
        fmt.Println(item)
    }

}

1.4. 数组嵌套

// [0,0,0]
//var nestData [3]int

// [ [  [0,0,0],[0,0,0]  ],[  [0,0,0],[0,0,0]  ],[  [0,0,0],[0,0,0]  ], ]
//var nestData [3][2][3]int

// [  [0,0,0],[0,0,0]  ]
//var nestData [2][3]int
//nestData[0] = [3]int{11, 22, 33}
//nestData[1][1] = 666
//fmt.Println(nestData)

//nestData := [2][3]int{[3]int{11, 22, 33}, [3]int{44, 55, 66}}
//fmt.Println(nestData)