一 . Array数组介绍

数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），这种类型可以是意的原始类型，比如int、string等，也可以是用户自定义的类型。一个数组包含的元素个数被称为数组的长度。在Golang中数组是一个长度固定的数据类型，数组的长度是类型的一部分，也就是说[5]int和[10]int是两个不同的类型。Golang中数组的另一个特点是占用内存的连续性，也就是说数组中的元素是被分配到连续的内存地址中的，因而索引数组元素的速度非常快。

blabla….就是数组长度不一样类型也不一样!

和数组对应的类型是Slice（切片），Slice是可以增长和收缩的动态序列，功能也更灵活

切片源自于数组 , 先学数组 !

二 . 数组定义+初始化

  1. var 数组变量名 [元素数量] T

示例

  1. // 数组的长度是类型的一部分
  2. var arr1 [3]int
  3. var arr2 [4]string
  4. fmt.Printf("%T, %T \n", arr1, arr2)
  6. // 数组的初始化 第一种方法
  7. //初始化数组时可以使用初始化列表来设置数组元素的值。
  8. var arr3 [3]int   //初始化为int类型的零值
  9. arr3[0] = 1
  10. arr3[1] = 2
  11. arr3[2] = 3
  12. fmt.Println(arr3)
  14. // 第二种初始化数组的方法
  15. //一次性初始化
  16. var arr4 = [4]int {10, 20, 30, 40}
  17. fmt.Println(arr4)
  19. // 第三种数组初始化方法，自动推断数组长度
  20. var arr5 = [...]int{1, 2}
  21. fmt.Println(arr5)
  23. // 第四种初始化数组的方法，指定下标
  24. a := [...]int{1:1, 3:5}
  25. fmt.Println(a)

三 . 遍历数组

方法1:for循环遍历

  1. // 第四种初始化数组的方法，指定下标
  2. a := [...]int{1:1, 3:5}
  3. // 方法1：for循环遍历
  4. for i := 0; i < len(a); i++ {
  5.     fmt.Print(a[i], " ")
  6. }

方法2:for range遍历

  1. // 第四种初始化数组的方法，指定下标
  2. a := [...]int{1:1, 3:5}
  3. // 方法2：for range遍历
  4. for _, value := range a {
  5.     fmt.Print(value, " ")
  6. }

四. 数组(值类型)

数组是值类型，赋值和传参会赋值整个数组，因此改变副本的值，不会改变本身的值

  1. // 数组
  2. var array1 = [...]int {1, 2, 3}
  3. array2 := array1
  4. array2[0] = 3
  5. fmt.Println(array1, array2)

例如上述的代码，我们将数组进行赋值后，该改变数组中的值时，发现结果如下

  1. [1 2 3] [3 2 3]

这就说明了，golang中的数组是值类型，而不是和java一样属于引用数据类型

五 . 切片定义(引用类型)

在golang中，切片的定义和数组定义是相似的，但是需要注意的是，切片是引用数据类型，如下

  1. // 切片定义
  2. var array3 = []int{1,2,3}
  3. array4 := array3
  4. array4[0] = 3
  5. fmt.Println(array3, array4)

我们通过改变第一个切片元素，然后查看最后的效果

  1. [3 2 3] [3 2 3]

六 . 二维数组

Go语言支持多维数组，我们这里以二维数组为例（数组中又嵌套数组）：

  1. var 数组变量名 [元素数量][元素数量] T

示例

  1. // 二维数组
  2. var array5 = [2][2]int{{1,2},{2,3}}
  3. fmt.Println(array5)

6.1 数组遍历

二维数据组的遍历

  1. // 二维数组
  2. var array5 = [2][2]int{{1,2},{2,3}}
  3. for i := 0; i < len(array5); i++ {
  4.     for j := 0; j < len(array5[0]); j++ {
  5.         fmt.Println(array5[i][j])
  6.     }
  7. }

遍历方式2

  1. for _, item := range array5 {
  2.     for _, item2 := range item {
  3.         fmt.Println(item2)
  4.     }
  5. }

6.2 类型推导

另外我们在进行数组的创建的时候，还可以使用类型推导，但是只能使用一个 …

  1. // 二维数组（正确写法）
  2. var array5 = [...][2]int{{1,2},{2,3}}

错误写法

  1. // 二维数组
  2. var array5 = [2][...]int{{1,2},{2,3}}

完整代码

  1. package main
  2. import "fmt"
  3. func main() {
  4.     // 数组的长度是类型的一部分
  5.     var arr1 [3]int
  6.     var arr2 [4]string
  7.     fmt.Printf("%T, %T \n", arr1, arr2)
  8.     // 数组的初始化 第一种方法
  9.     var arr3 [3]int
  10.     arr3[0] = 1
  11.     arr3[1] = 2
  12.     arr3[2] = 3
  13.     fmt.Println(arr3)
  14.     // 第二种初始化数组的犯法
  15.     var arr4 = [4]int {10, 20, 30, 40}
  16.     fmt.Println(arr4)
  17.     // 第三种数组初始化方法，自动推断数组长度
  18.     var arr5 = [...]int{1, 2}
  19.     fmt.Println(arr5)
  20.     // 第四种初始化数组的方法，指定下标
  21.     a := [...]int{1:1, 3:5}
  22.     fmt.Println(a)
  23.     for i := 0; i < len(a); i++ {
  24.         fmt.Print(a[i], " ")
  25.     }
  26.     for _, value := range a {
  27.         fmt.Print(value, " ")
  28.     }
  29.     fmt.Println()
  30.     // 值类型 引用类型
  31.     // 基本数据类型和数组都是值类型
  32.     var aa = 10
  33.     bb := aa
  34.     aa = 20
  35.     fmt.Println(aa, bb)
  36.     // 数组
  37.     var array1 = [...]int {1, 2, 3}
  38.     array2 := array1
  39.     array2[0] = 3
  40.     fmt.Println(array1, array2)
  41.     // 切片定义
  42.     var array3 = []int{1,2,3}
  43.     array4 := array3
  44.     array4[0] = 3
  45.     fmt.Println(array3, array4)
  46.     // 二维数组
  47.     var array5 = [...][2]int{{1,2},{2,3}}
  48.     for i := 0; i < len(array5); i++ {
  49.         for j := 0; j < len(array5[0]); j++ {
  50.             fmt.Println(array5[i][j])
  51.         }
  52.     }
  53.     for _, item := range array5 {
  54.         for _, item2 := range item {
  55.             fmt.Println(item2)
  56.         }
  57.     }
  58. }