Go语言复合数据类型之数组

Go语言基本数据类型之数组

数组定义

数组是由固定长度的特定类型元素组成的序列，数组的长度是固定的，不允许改变。

访问数组可以根据索引下标来访问，索引的范围 0 到 数组长度 左闭右开区间。

数组定义时，必须声明数组的长度

var aaa [3]int
// var 变量名 [数组长度]元素类型

数组的长度必须是常量，因为数组长度需要在编译器确定，以下这种定义方式是错误的。

var b int = 3
var aaa [b]int //报错 数组长度不允许是变量

数组初始化

数组初始化的几种方式如下

1. 数组可以只声明，默认初始化的值为元素类型的初始值
2. 定义时指定数组元素值
3. 数组长度由数组中元素的个数推导而出
4. 自定义数组中特定下标的元素值，没有被指定的则为元素类型的初始值

  var aaa [3]int 
  var bbb = [3]int{1, 2, 3}
  var ccc = [...]int{1, 2, 3}
  var ddd = [...]int{1: 1, 4: 4}
  fmt.Println(aaa)  //[0 0 0]
  fmt.Println(bbb) //[1 2 3]
  fmt.Println(ccc) //[1 2 3]
  fmt.Println(ddd) //[0 1 0 0 4]

数组遍历

1. 常规for循环遍历，根据下标来索引

  var eee = [3]string{"hello", "world", "golang"}
  for i := 0; i < len(eee); i++ {
    fmt.Println(eee[i])
  }

2. 使用for-range 遍历 ，语法类似于for-each

	var eee = [3]string{"hello", "world", "golang"}
	for _, e := range eee { //_为index下标，匿名变量
		fmt.Println(e)
	}

数组的比较

数组的长度是数组的一部分，所以不同长度的数组是无法比较的,

如果一个数组元素类型是可以相互比较的，那么数组类型也是可以相互比较的，这时候我们可以直接通过==比较运算符来比较两个数组。只有每个元素都相等，才返回true。

	f := [3]int{1, 2, 3}
	g := [4]int{1, 2, 3}
	h := [3]int{1, 2, 3}
	if f == g //invalid operation: f == g (mismatched types [3]int and [4]int)
	fmt.Println(f == h)//true

二维数组

开发中经常会用到二维数组，二维数组就是数组的嵌套

	//二维数组
	twoArray := [3][2]string{
		{"hello", "world"},
		{"中国", "你好"},
		{"平安", "快乐"},
	}

对于嵌套数组外层的数组长度是可以根据内层数组数量来推导的

	twoArray2 := [...][2]string{
		{"hello", "world"},
		{"中国", "你好"},
		{"平安", "快乐"},
	} 

但内层不允许推导

	twoArray3 := [3][...]string{ //编译报错
		{"hello", "world"},
		{"中国", "你好"},
		{"平安", "快乐"},
	} //use of [...] array outside of array literal

补充知识点

for range遍历字符串

“%t"打印布尔型，”%T"打印数据类型 ，"%c"打印字符

1. 字符串是由于unicode编码字符组成的集合，那么for range之后， s是一个rune类型，所以打印出了字符，循环的索引都是当前rune的起始位置。

	ss := "中国人"
	for index, s := range ss {
		fmt.Printf("下标->%d  字符->%#U  类型->%T", index, s, s)
		fmt.Println()
	}
下标->0  字符->U+4E2D '中'  类型->int32
下标->3  字符->U+56FD '国'  类型->int32
下标->6  字符->U+4EBA '人'  类型->int32

2. 索引字符串可以访问单个字节，而不是字符。

	ss := "中国人"
	for i := 0; i < len(ss); i++ { //ss[i]是字节值
		fmt.Printf("下标->%d  字符->%#U  类型->%T", i, ss[i], ss[i])
		fmt.Println()
	}

下标->0  字符->U+00E4 'ä'  类型->uint8
下标->1  字符->U+00B8 '¸'  类型->uint8
下标->2  字符->U+00AD  类型->uint8
下标->3  字符->U+00E5 'å'  类型->uint8
下标->4  字符->U+009B  类型->uint8
下标->5  字符->U+00BD '½'  类型->uint8
下标->6  字符->U+00E4 'ä'  类型->uint8
下标->7  字符->U+00BA 'º'  类型->uint8
下标->8  字符->U+00BA 'º'  类型->uint8

3. 如果想要直接下标访问 需要将字符串转成rune数组。

	//不用遍历 直接下标访问
	ss := "中国人"
	runes := []rune(ss)
	fmt.Printf("%c", runes[0])

注：字符串的本质是字节组成的slice！

下一篇将会介绍slice切片