golang第八天，数组

这是我参与8月更文挑战的第8天，活动详情查看：8月更文挑战

什么是数组

golang提供了数组类型的数据结构。数组是具备相同惟一类型的一组已编号且长度固定的数据项序列，这种类型能够是任意的原始类型，例如（整形，字符串或者自定义类型）。

数组元素能够经过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。（数组以 0 开始在全部类 C 语言中是类似的）数组的下标取值范围是从0开始的，到长度减1

数组长度必须是一个常量表达式，而且必须是一个非负整数。数组长度也是数组类型的一部分，因此[5]int和[10]int是属于不一样类型的。

数组一旦定义后，大小不能更改（编译时须要知道数组长度以便分配内存）。

总结：

• 数组是长度固定的数据类型
• 数据元素的类型相同
• 数组是从0开始的，一直到长度减1为结束
• 数组长度是一个常量表达式，而且是一个非负整数

做用及应用场景

做用：组在内存中是连续的存储空间，能够有效的提高cpu的执行效率

应用场景：存储多个相同类型的数据时，可使用数组

数组的定义和语法

一维数组的定义方式

初始化自定义

var arr [10] int
arr[0] = 100
arr[2] = 200
fmt.Println(arr)  // [100, 0, 200, 0, 0, 0, 0, 0, 0, 0]
复制代码

初始赋值定义法

var arr [2] int = [2] int {1, 2}
for i := 0; i < len(arr); i++ {
    fmt.Println(i, arr[i])
}
复制代码

注意：这里有个坑，var arr[2] int = [2]int{ 1, 2 }, 是花括号，而不是中括号。。一开始我踩坑了。

不用定义长度，简略赋值法

package main

import "fmt"

func main() {
	arr := [...]int{1, 2, 3, 4, 5}
	fmt.Println(arr)
}
复制代码

注意，简略赋值，不须要用var或者const声明

二维数组

package main

import "fmt"

func main() {
    var arr1 [2][3]int
    fmt.Println(arr1)  // [[0 0 0] [0 0 0]]

    arr2 := [2][3]int{{1, 2, 4}, {3, 4, 3}}
    fmt.Println(arr2)  // [[1 2 4] [3 4 3]]

    arr3 := [4][3]int{1: {1, 1, 1}, 2: {2, 2, 2}}
    fmt.Println(arr3)  // [[0 0 0] [1 1 1] [2 2 2] [0 0 0]]
}
复制代码

注意，这里arr1不能使用 :=，会报type [2][3]int is not an expression,因为[2][3]int这不是一个表达式

多维度，多个数组

初始定义

package main

import "fmt"

func main() {
    var arr [4][3][2]int = [4][3][2]int{}
    fmt.Println(arr)
    // [[[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]]]
}
复制代码

示例：

package main

import "fmt"

func main() {
    /*

    一维数组：存储的多个数据是数值自己
        a1 :=[3]int{1,2,3}

    二维数组：存储的是一维的一维
        a2 := [3][4]int{{},{},{}}

        该二维数组的长度，就是3。
        存储的元素是一维数组，一维数组的元素是数值，每一个一维数组长度为4。

    多维数组：。。。

     */
    a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
    fmt.Println(a2)
    fmt.Printf("二维数组的地址：%p\n", &a2)
    fmt.Printf("二维数组的长度：%d\n", len(a2))

    fmt.Printf("一维数组的长度：%d\n", len(a2[0]))
    fmt.Println(a2[0][3]) // 4
    fmt.Println(a2[1][2]) //7
    fmt.Println(a2[2][1]) // 10

    //遍历二维数组
    for i:=0;i<len(a2);i++{
        for j:=0;j<len(a2[i]);j++{
            fmt.Print(a2[i][j],"\t")
        }
        fmt.Println()
    }

    fmt.Println("---------------------")
    //for range 遍历二维数组
    for key1,val1 := range a2{
        for key2,val2 := range arr{
            fmt.Print(val2,"\t")
        }
        fmt.Println()
    }
}
复制代码

其余类型的数组建立方式

var a [4] float32 // 等价于：var arr2 = [4]float32{}
  fmt.Println(a) // [0 0 0 0]
  var b = [5] string{"ruby", "王二狗", "rose"}
  fmt.Println(b) // [ruby 王二狗 rose  ]
  var c = [5] int{'A', 'B', 'C', 'D', 'E'} // byte
  fmt.Println(c) // [65 66 67 68 69]
  d := [...] int{1,2,3,4,5}// 根据元素的个数，设置数组的大小
  fmt.Println(d)//[1 2 3 4 5]
  e := [5] int{4: 100} // [0 0 0 0 100]
  fmt.Println(e)
  f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
  fmt.Println(f)
复制代码

数组是值类型

golang中的数组是值类型，而不是引用类型。这意味着当它们被分配给一个新变量时，将把原始数组的副本分配给新变量，若是对新变量进行了更改，则不会在原始数组中反映

package main
import "fmt"
func main() {
    a := [...]string{"a", "b", "c"}
    b := a
    b[0] = "小阿肥"
    fmt.Println("a is: ", a)
    fmt.Println("b is: ", b)
}
复制代码

数组的排序

数组的排序，就是让一个数组中的数据，根据必定的算法，最终是数值有顺序的，能够从小到大(升序)，也能够从大到小(降序)。默认是升序。

排序算法也有不少种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，堆排序等等。

倒序

arr := [5]int{15, 23, 8, 10, 7}
for i := 0; i < len(arr) - 1; i++ {
  if(arr[i] < arr[i + 1]) {
     t := arr[i]
     arr[i] = arr[i + 1]
     arr[i + 1] = t
  }
}
fmt.Println(arr)
复制代码

数组的注意事项

• 数组是值类型
• len()获取长度
• 数组的长度是数组类型的组成部分
• 数组在内存当中是连续的存储空间
• 数组作为参数以引用形式传递函数，意义重大，当传递较大的数组时能够有效的提高cpu执行效率
• 数组作为值类型来传递函数,调用时是值拷贝，若是较大的数组传递对cpu的效能消耗是极其大的

最后

刚学golang，但愿你们监督而且一块儿努力

有兴趣的小伙伴，欢迎关注我订阅号：EntrepreneurialG