linux数组操作 增删改查,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

除非另有说明，否则本站上的内容根据以下许可进行许可: CC署名-非商业性使用-相同方式共享4.0国际许可协议4.0进行许可

本文作者：www.linuxea.com for Mark

文章链接：http://www.linuxea.com/2494.html (转载请注明本文出处和本章链接)