要了解数组，必须先了解一下Go的数据类型的另一种分类（上一种是非引用数据类型和引用数据类型，可以参考上一篇文章）
1、基本数据类型：整形、浮点、不二、字符串、字符
2、复合数据类型：函数与指针、数组、切片、map、list、结构体、通道
数组：素组元素可以通过索引下标来读取或者修改元素数据，索引从0开始以此类推。
素组初始化以后，大小不能更改。
声明数组的语法格式：
var 变量名 [数组长度]数据类型
这是一维数组的定义方式，数组长度必须是整数且大于0，未初始化的数组不是nil，也就是说没有空数组（与切片不同）
没有初始化的数组，int类型的默认是0，string类型的默认是” “空格，所以不会出现java的空指针异常。

初始化素组：

  1. var array = [3]int{1,2,3}

初始化数组中的{}中的元素不能大于[]中的数字。
如果忽略[]中的数字不设置数组大小，Go语言会根据元素的个数来设置数组的大小。

  1. var nums = [...]int{1,2,3}

将声明中的[]数字替换为…编译器会自动计算长度。

数组的长度：

通过数组作为参数传递给 len() 函数，可以获得数组的长度。
一维数组的声明及遍历代码：一个标准的for循环遍历及一个range调用遍历

  1. //声明和定义一维数组
  2. var arr1 [3]string
  3. var arr2 = [3]int{1, 2, 3}
  4. var arr3 = [...]int{1, 2, 3, 4, 5}
  6. func main() {
  7.     arr4 := [4]string{"a", "b", "c", "d"}
  9.     for i := 0; i < len(arr4); i++ {
  10.         fmt.Print(arr4[i], "\t")
  11.     }
  12.     fmt.Print("\n")
  13.     for _, value := range arr1 {
  14.         fmt.Print(value, "\t")
  15.     }
  16. }

运行结果如下：

  1. a    b    c    d

各位看官，因为数组arr1没有进行初始化，所以结果下面是有一排空格的，动动鼠标可以看到。

二维数组：
二维数组是最简单的多维数组，二维数组本质上是由一堆一维数组组成的。
二维数组的定义方式：
var 变量名 [x][y]变量类型
二维数组的声明及遍历代码：还是一个标准的for循环遍历及一个range调用遍历

  1. var arrayarr = [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
  3. func main() {
  4.     for i := 0; i < len(arrayarr); i++ {
  5.         for j := 0; j < len(arrayarr[i]); j++ {
  6.             fmt.Print(arrayarr[i][j], "\t")
  7.         }
  8.         fmt.Print("\n")
  9.     }
  11.     for _, val1 := range arrayarr {
  12.         for _, val2 := range val1 {
  13.             fmt.Print(val2, "\t")
  14.         }
  15.         fmt.Print("\n")
  16.     }
  17. }

运行结果：

  1. 1    2    3    4    
  2. 5    6    7    8    
  3. 9    10    11    12    
  4. 1    2    3    4    
  5. 5    6    7    8    
  6. 9    10    11    12


再来通过一段代码证明数组是非引用数据类型：

  1. func main() {
  2.     a := [...]string{"a", "b", "c", "d"}
  3.     b := a
  4.     b[0] = "x"
  5.     fmt.Println("a:", a)
  6.     fmt.Println("b:", b)
  7. }

运行代码获得结果：

  1. a: [a b c d]
  2. b: [x b c d]

我们可以看到，当数组b改变时，并未影响到数组a，由此可以证明数组是非引用数据类型。

2019年9月2日，补充一种数组的声明及定义：
通过设定下标来定义数组：
数组名 = […]数组类型{数组元素，下标:数组元素，数组元素…}
如果定义的最小下标不是起始值0，且前面没有数据，则前面的数值都为0

  1. //补充一种确定下标的数组声明及定义方式：
  2. func testArray04(){
  3.     //a1数组下标0的没有定义，默认为0，下标1的是2，下标2的是3，
  4.     a1 := [...]int{2:3,1:2}
  5.     fmt.Println(a1)      //[0 2 3]
  7.     //a2数组下标4定义为5，之前下标2和3未定义，默认为0
  8.     a2 := [...]int{1,2,4:5,6}
  9.     fmt.Println(a2)      //[1 2 0 0 5 6]
  10. }

数组去重,去空

  1. /** * 数组去重 去空 */
  2. func removeDuplicatesAndEmpty(a []string) (ret []string) {
  3.     vlen := len(a)
  4.     for i := 0; i < vlen; i++ {
  5.         if (i > 0 && a[i-1] == a[i]) || len(a[i]) == 0 {
  6.             continue
  7.         }
  8.         ret = append(ret, a[i])
  9.     }
  10.     return
  11. }

数组拼接

  1. import "strings"
  3. arr := []string{"hello","world"}
  5. arrString := strings.Join(arr , ";")