linuxea:go数组与数组增删改查(19)



复合数据类型是集合类,并且可以存储多个单值。

在golang中存储的数组是相同的数据类型,并且长度也是其中的一个属性。在go中,数组的长度一旦定义,就不可变。如果声明了长度的变量,只能赋值相同的长度的数组

数组是具有相同数据类型的数据项组成一组长度固定的序列,数据项叫做数组的元素,数组的长度必须是非负整数的常量,长度也是类型的一部分。

1.2 数组的声明

声明数组组成的元素类型以及存储的元素长度,一旦数组长度设置后不可以更改,数组的每个元素会根据对应类型的零值进行初始化。

使用var进行声明即可,长度和类型

var nums [10]int

如上,数组使用中括号[],上述表示一个长度为10的int类型数组。

package main

import "fmt"

func main() {
    var nums [10]int
    fmt.Printf("%T ", nums)
    fmt.Println("\n", nums)
}

我们可以打印下这个nums

[root@www.linuxea.com /opt/Golang/work2]# go run array.go 
[10]int 
[0 0 0 0 0 0 0 0 0 0]

!!! note
当定义了[10]int的时候,就会在内存申请10个int类型的元素。元素内的值是对应类型的零值存放。

所以,这里打印的是10个0。

我们可以多定义几个其他类型

package main

import "fmt"

func main() {
    var nums [10]int
    var t1 [5]bool
    var t2 [3]string
    fmt.Printf("%T ", nums)
    fmt.Println("\n", nums)
    fmt.Println(t1)
    fmt.Printf("%q",t2)
}
  • %q可以打印空字符串带"",便于查看

运行结果如下:

[root@www.linuxea.com /opt/Golang/work2]# go run array.go 
[10]int 
 [0 0 0 0 0 0 0 0 0 0]
[false false false false false]
["" "" ""]

分别是,10个0,5个false,3个空字符串

1.2数组的赋值

赋值的时候,需要和定义时候一样,假如你赋值如下:

nums = [10]int{}

这和上面定义的变量是一样,因为{}是空,都会是0值。

我们设置1~5

package main

import "fmt"

func main() {
    var nums [10]int
    nums = [10]int{1,2,3,4,5}
    fmt.Println(nums)
}   

这里也可以简短声明: nums := [10]int{1,2,3,4,5}

运行:

[root@www.linuxea.com /opt/Golang/work2]# go run array.go 
[1 2 3 4 5 0 0 0 0 0]

这时候你会发现,赋值是正确了,但是仍然打印了10个元素,前五个被赋值了,没有赋值的仍然是0.

1.3数组索引赋值

我们在换种方式,对第一个和最后一个进行赋值。

如果要进行这种赋值操作,必须使用索引,第一个就是0,最后一个就是9。

将第一个赋值为10,最后一个赋值为20,如下:

nums = [10]int{0:10,9:20}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array.go 
[10 0 0 0 0 0 0 0 0 20]

我们也可以使用[...]来省略长度,但是必须输够长度

我们可以使用[...]的方式来进行自动推导有多少数组,而不是设置一个固定的值

package main

import "fmt"

func main() {
    var nums [10]int
    nums = [...]int{0:10,9:20}
 
}   

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array.go 
[10 0 0 0 0 0 0 0 0 20]

或者这样

nums02 := [...]int{1,2,3,4}
package main

import "fmt"

func main() {
    nums02 := [...]int{1,2,3,4}
    fmt.Println(nums02)
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
[1 2 3 4]

1.4数组的操作

定义nums01和nums02数组进行判断

package main

import "fmt"

func main() {
    nums01 := [...]int{0,1,2,3}
    nums02 := [...]int{1,2,3,4}
    fmt.Println(nums02 == nums01)
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
false

或者不等于

package main

import "fmt"

func main() {
    nums01 := [...]int{0,1,2,3}
    nums02 := [...]int{1,2,3,4}
    fmt.Println(nums02 != nums01)
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
true

!!! warning
如果长度不相等是不能进行运算.
可以使用len计算数组的长度

1.5数组的索引操作

nums02 := [...]int{1,2,3,4}

我们现在获取位于2和3的索引位置的数据.

  • 索引范围必须在可选值内 ,0~ len-1
package main

import "fmt"

func main() {
    nums02 := [...]int{1,2,3,4}
    fmt.Println(nums02[1],nums02[2])
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
2 3
  • 修改

将索引0改成666

nums02 := [...]int{1,2,3,4}
nums02[0] = 666

而后在打印这个修改的索引0

fmt.Println(nums02[0])

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
666

这里已经被修改。

1.6数组的遍历

  • 使用for遍历上述的数组
package main

import "fmt"

func main() {
    nums02 := [...]int{1,2,3,4}
    nums02[0] = 666
    for i :=0; i< len(nums02); i++{
        fmt.Println(i,":",nums02[i])
    }
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
0 : 666
1 : 2
2 : 3
3 : 4
  • for range遍历
package main

import "fmt"

func main() {
    nums02 := [...]int{1,2,3,4}
    nums02[0] = 666
    for index,value := range nums02 {
        fmt.Println(index,":",value)
    }
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go
0 : 666
1 : 2
2 : 3
3 : 4
0 : 666

我们也可以使用下划线,空白符来不接收

package main

import "fmt"
func main() {
    nums02 := [...]int{1,2,3,4}
    nums02[0] = 666
    for _,value := range nums02 {
        fmt.Println(value)
    }
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array1.go 
666
2
3
4

###1.7数组的切片操作

切片可以获取一部分,字符串和数组都可以获取一部分。如下

和之前字符串一样,end不能超过其长度,最多和长度一样。

我们设置start为0,end为3,我们先看下这个切片的类型

package main

import "fmt"

func main() {
    var nums [10]int
    nums = [10]int{1,2,3,4,5}
    fmt.Printf("%T",nums[1:10])
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run array.go
[]int

数组切片之后的并不是是数组,而是另外的切片。

  • 切片在字符串是用字符串的某一段组成的新的字符串。
  • 切片在数组是数组中的元素组成一个新的集合。

在切片之后还可以跟一个值,这个值是容量,但是仍然不可以超过最大值。

package main

import "fmt"

func main() {
    var nums [10]int
    nums = [10]int{1,2,3,4,5}
    fmt.Printf("%T",nums[1:10])
    fmt.Printf("%T",nums[1:10:10])
}
[root@www.linuxea.com /opt/Golang/work2]# go run array.go
[]int[]int
0 分享

您可以选择一种方式赞助本站

支付宝扫码赞助

支付宝扫码赞助

日期: 2019-10-25分类: Golang

标签: Golang

发表评论