golang学习笔记--数组使用总结

数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。

1.数组的几种创建方式

• 使用数组长度和指定数据初始化进行创建

  arr1 := [10]int {3,6,9,4,5,3,5,7,8,2}
  fmt.Println(arr1)
  // [3 6 9 4 5 3 5 7 8 2]
  fmt.Println(len(arr1))
  // 10
  

   

• 根据初始化参数的个数来创建

  arr2 := [...]int {3,6,9,4,5,3,5,7,8}
  fmt.Println(arr2)
  // [3 6 9 4 5 3 5 7 8]
  fmt.Println(len(arr2))
  // 9

   

• 按指定长度0值初始化元素创建。第一个数值指定长度0值长度个数

  arr3 := [...]int{10:2,-1}
  fmt.Println(arr3)
  // [0 0 0 0 0 0 0 0 0 0 2 -1]
  fmt.Println(len(arr3))
  // 12 --> 10个0 + 后续两个数据

   

2.数组的访问

数组的每个元素可以通过索引下标来访问，索引下标的范围是从0开始到数组长度减1的位置。可以使用go内置函数len()获取数据的长度。

arr4 := [...]int{10: 2,-1}
fmt.Println(arr4[10])
// 2

数组的循环访问

arr5 := [...]int{10: 2,-1}
for _, v := range arr5 {
    val := v        // 复制
	fmt.Printf("%d\n", val)
}

 

3.官方对数组使用说明

• Arrays are values. Assigning one array to another copies all the elements. 
• In particular, if you pass an array to a function, it will receive a copy of the array, not a pointer to it.   
• The size of an array is part of its type. The types [10]int and [20]int are distinct.  数组的大小是其类型的一部分。[10]int类型和[20]int类型是不同的

1.   数组是一个值对象，将一个数组赋值给另一个数组将复制所有元素。

   arr6 := [...]int{0,0,0}
   arr7 := arr6
   arr7[2] = 2
   fmt.Println(arr6)
   fmt.Println(arr7)
   // arr6 --> [0 0 0]
   // arr7 --> [0 0 2]

    

2. 如果将数组传递给函数，它将接收数组的副本，而不是指向该数组的指针。

   arr8 := [2]int{1,2}
   fmt.Println(arr8)
   swap(arr8)
   fmt.Println(arr8)
   // [1 2]
   // [1 2]
   
   func swap(arr8 [2]int){
   	temp :=  arr8[0]
   	arr8[0] = arr8[1]
   	arr8[1] = temp
   }

    如果想通过数组进行引用传递，则需要传数组的指针类型

   arr8 := [2]int{1,2}
   fmt.Println(arr8)
   swap(&arr8)
   fmt.Println(arr8)
   
   func swap(arr8 *[2]int){
   	temp :=  arr8[0]
   	arr8[0] = arr8[1]
   	arr8[1] = temp
   }
   // [1 2]
   // [2 1]

    

3. 数组的大小是其类型的一部分。[10]int类型和[20]int类型是不同的。

arr9 := [...]int{0,0,0}
arr9 = [...]int{0,0,0,0}  // Cannot use '[...]int{0,0,0,0}' (type [4]int) as type [3]int

如果数组的大小(长度)不一直，编译器会直接提示他们type不同。  

4.扩展说明

1. 数组比较的问题。直接通过==比较运算符来比较两个数组，只有当两个数组的所有元素都是相等的时候数组才是相等的

   arr10 := [3]int{1,1,1}
   arr11 := [3]int{1,1,1}
   fmt.Println(arr10 == arr11)
   // true
   
   arr12 := [3]int{1,1,1}
   arr13 := [...]int{1,1,2}
   fmt.Println(arr12 == arr13)
   // false

    

2. 数组和slice的转换

   arr14 := [10]int {3,6,9,4,5,3,5,7,8,2}
   // fmt.Println(append(arr14,10))  会报错，Cannot use 'arr14' (type [10]int) as type []Type
   arr15 := arr14[:5]
   fmt.Println(arr15)
   arr16 := append(arr15,10)
   fmt.Println(arr16)
   // [3 6 9 4 5]
   // [3 6 9 4 5 10]

    

3. this style isn't idiomatic Go. Use slices instead. 官方说数组这种风格不是惯用的。建议使用切片