Go语言复合数据类型(1)–数组 – 21运维
通知: .-...

Go语言复合数据类型(1)–数组

GO 21运维 326浏览

Go语言为了编程效率的提高,吸收了其他语言的特性,也直接定义好了一些复杂的数据类型。
目前Go语言有4中复合数据类型:数组、切片、map和结构体

数组
数组是固定大小的连续空间
1,声明数组
var 变量名 [数组长度]数据类型
注意:
(1)数组长度可以是一个值,也可以是一个表达式。表达式的结果必须是整型。
(2)数据类型可以是任意基本类型,也可以是数组,这样就可以构成多维数组
(3)数组元素可以通过 “变量[下标]“进行独立访问输出。

2,初始化数组
可以先声明,后初始化。
也可以声明的时候直接初始化变量,右值用大括号,元素值之间用逗号”,”分割。。
ps: 左侧声明的时候,可以不加数组长度,右值用[…],系统会自动计算数组长度。

package main

import (
   "fmt"
)

func main(){
   var devops [3]string
   devops[0] = "swh"
   devops[1] = "cq"
   devops[2] = "xp"
   //分别输出数组的每一个元素
   for i:=0;i<len(devops);i++{
      fmt.Println(devops[i])
   }
   //分别输出数组的每一个元素
   for _,v := range devops{
      fmt.Println(v)
   }
   //输出整个数组
   fmt.Println(devops)

   //定义数组并直接声明,采用大括号{}直接针对数组元素赋值
   var weapon  =  [...]string{"gun","hammer","knife"}
   fmt.Println(weapon)
}


输出结果:
swh
cq
xp
swh
cq
xp
[swh cq xp]
[gun hammer knife]

3,遍历数组
使用内置range进行遍历数组,range 处理数组,可以返回两个值得:索引和对应数组元素的值

package main

import (
   "fmt"
)

func main(){
   var devops [3]string
   devops[0] = "swh"
   devops[1] = "cq"
   devops[2] = "xp"
   //遍历输出数组的每一个元素
   for i:=0;i<len(devops);i++{
      fmt.Println(devops[i])
   }
   //遍历输出数组的每一个元素,采用range。这里不输出下标,用占位符
   for _,v := range devops{
      fmt.Println(v)
   }
   //输出整个数组
   fmt.Println(devops)

   //定义数组并直接声明,采用大括号{}直接针对数组元素赋值
   var weapon  =  [...]string{"gun","hammer","knife"}
   fmt.Println(weapon)
}

输出结果:
swh
cq
xp
[swh cq xp]

4,比较两个数组是否相等
如果两个数组类型相同(包括数组的长度,数组中元素的类型)的情况下,我们可以直接通过较运算符(==和!=)来判断两个数组是否相等,只有当两个数组的所有元素都是相等的时候数组才是相等的,不能比较两个类型不同的数组,否则程序将无法完成编译。

package main

import "fmt"

func main(){
   a := [2]int{1,2}
   b := [...]int{1,2}
   c := [2]int{1,3}
   d := [3]int{1,2}

   fmt.Println(a == b)
   fmt.Println(a == c)
   fmt.Println(b != c)

输出结果:
true
false
true

如果改成:

a := [2]int{1,2}
b := [...]int{1,2}
c := [2]int{1,3}
d := [3]int{1,2}

fmt.Println(a == b)
fmt.Println(a == c)
fmt.Println(b != c)
fmt.Println(a == d)

会报错,原因:a和d是不同类型的数组,数组长度都不一样,不具有可比性。

5,数组指针。
和指针的用法一样,只不过是一个数组类型的指针而已。

可以使用new([长度]{}) 声明一个指向数组的指针,通过指针传参操作时能减小复制整个数组的开销。

package main

import "fmt"
func main(){
   var array *[4]int = new([4]int)
   fmt.Println(len(array))
   fmt.Println(array)
   array[0] = 100
   array[1] = 200
   array[2] = 300
   array[3] = 400
   for _,value := range array{
      fmt.Println(value)
   }
}

输出结果:
4
&[0 0 0 0]
100
200
300
400

6,多数数组。这里只记录二维,和c语言类似。

package main

import "fmt"
func main(){
   //定义一个二维数组,里边含有两个元素
   var  a  [2][2]int = [2][2]int{{1,2},{3,4}}
   fmt.Println(len(a))
   fmt.Println(a)

   //定义一个二维数组,里边含有两个元素
   var b [2][3]int = [2][3]int{{1,2,3},{4,5,6}}
   fmt.Println(len(b))
   fmt.Println(b[1])
   fmt.Println(b[1][2])
}

输出结果:
2
[[1 2] [3 4]]
2
[4 5 6]
6

转载请注明:21运维 » Go语言复合数据类型(1)–数组