go之数组

数组

　　数组是同一类型元素的集合。例如整数集合5,8,9,10形成一个数组，go语言中不允许混合不同类型的元素，例如包含字符串和整数的数组

　　数组是连续存储的内存空间，一旦申请，大小固定，不能再改变

定义没有初始化

?

1 2 3 4 5 6 7 8

package main   import "fmt"   func main() {     var a [3]int  // 没有初始化，默认值是 0 0 0     fmt.Println(a) }

定义并初始化　

?

1 2 3 4 5 6 7 8 9 10

package main   import "fmt"   func main() {     var a [3]int=[3]int{4,7}  // 少于长度可以，多于不行     //var a =[3]int{4,7}  // 少于长度可以，多于不行     //a :=[3]int{4,7}  // 少于长度可以，多于不行     fmt.Println(a)  //[4 7 0] }

定义并初始化其中一个

?

1 2 3 4 5 6 7 8 9

package main   import "fmt"   func main() {     var a [10]int=[10]int{8:99,6:77}     fmt.Println(a) } //[0 0 0 0 0 0 77 0 99 0]

定义并附初值的另一种方式

?

1 2 3 4 5 6 7 8 9

package main   import "fmt"   func main() {     //var a =[...]int{3,5,7,9}  // 意思并不是数组可变长，意思是使用后面的值来确定数组的长度  [3 5 7 9]     var a =[...]int{9:888}  // 意思并不是数组可变长，意思是使用后面的值来确定数组的长度  [0 0 0 0 0 0 0 0 0 888]     fmt.Println(a) }

数组取值赋值

?

1 2 3 4 5 6 7 8 9 10 11

package main   import "fmt"   func main() {     var a =[...]int{3,5,7,9}     fmt.Println(a[0])  // 取值 3     //fmt.Println(a[4])  // 直接越界  ，数组长度只有4     a[1]=999     fmt.Println(a)  //赋值[3 999 7 9] }

数组大小是类型的一部分

?

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

package main   import "fmt"   func main() {     //var a =[4]int{3,5,7,9}     var a =[5]int{3,5,7,9}     var b =[5]int{3,5,7,9}     if a==b{         fmt.Println("hello world")  //hello world     } }

数组是值类型，在函数中当参数传递

　　go语言中函数的参数传递都是copy传递，不会影响原来的

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package main   import "fmt"   func main() {     var b =[5]int{3,5,7,9}     test(b)  // 把b复制一份传过去，传到函数内部，新的b，在函数中改了新的b不会影响原来的     // 通过指针，可以操作     fmt.Println(b) }   func test(b [5]int)  {     b[0]=999  // 改了，会不会影响原来？     fmt.Println("函数内部",b)   } //函数内部 [999 5 7 9 0] //[3 5 7 9 0]

数组的长度，内置函数len

?

1 2 3 4 5 6 7 8

package main   import "fmt"   func main() {     var b =[5]int{3,5,7,9}     fmt.Println(len(b))  //5 }

使用range迭代数组

　　方式一：基于索引

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

package main   import "fmt"   func main() {     var b =[5]int{3,5,7,9}     for i:=0;i<len(b);i++{     fmt.Println(b[i])     } }   //3 //5 //7 //9 //0

　　方式二：基于迭代

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package main   import "fmt"   func main() {     var b =[5]int{3,5,7,9}     for i,v:=range b{     fmt.Println(i,v)     } } //0 3 //1 5 //2 7 //3 9 //4 0

多维数组

　　最多写两层即可，多写不好

?

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

package main   import "fmt"   func main() {     var b [3][2]int     fmt.Println(b) //[[0 0][0 0][0 0]]     var a [3][2]int = [3][2]int{{1, 2}, {4}, {6, 7}}     fmt.Println(a) //[[1 2] [4 0] [6 7]]     //取值赋值     a[0][1] = 999     fmt.Println(a) //[[1 999] [4 0] [6 7]] }

循环二维数组--两层循环

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package main   import "fmt"   func main() {     var a [3][2]int=[3][2]int{{1,2},{4,},{6,7}}     for _,v:=range a {         for _, v1 := range v {             fmt.Println(v1)         }     } } //1 //2 //4 //0 //6 //7