基本特性

• 格式： var Name [n]<type>,n>0 如： var a [10]int 表示，定義一個長度為10，元素類型為int性的數組
• 數組長度： 長度（len）也是數組類型的一部分，因此具有不同長度的數組為不同的類型。 如var a [2]int ！= var a [2]int

• 註意區分指向數組的指針和指針數組

  // 指向數組的指針：變量是指針
  a :=[...]int[9:1]   //頂一個變量a的數組(長度為100,第100個元素為1）
  var p *[...]int = &a //定義一個p的變量，類型為指針
  
  //指針數組：變量是數組，元素是指針(內存地址)
  x , y := 1,2
  b :=[...]*int(&x,&y)
  
  print (p)
  print (b)
  /*輸出結果：
  p---> &[0 0 0 0 0 0 0 0 0 9]
  b---> [0xc04200c0a8 0xc04200c0c0]
  */ 
   
  

• 數組在Go中屬於值類型

• 數組之間可以使用 ==或!=進行比較，但不可以使用<或>，比較是否相等，必須比較長度，類型，元素

  // 可以使用==和！=對兩個數組進行比較
  package main
  import (
      "fmt"
  )
  func main() {
      a := [2]int{1, 2}
      b := [2]int{1, 2}
      c := [2]int{1, 3}
      fmt.Println(a == b) //判斷兩個數組是否相同
      fmt.Println(a == c) //判斷兩個數組是否相同
  }
  /*輸出
  a==b ----> true
  a==c ----> false
  */
   
  

• 可以使用new類創建數組，此仿佛返回一個指向數組的指針（內存地址）

  package main
  import (
      "fmt"
  )
  func main() {
      a := [5]int{}
      a[1] = 2 //設定數組第二個元素的值為2
      fmt.Println(a)
      p := new([5]int) //new方法創建一個數組，返回的是一個數組的指針
      fmt.Println(p)
      p[1] = 2
      fmt.Println(p) //數組的指針賦值後，可以達到同樣的效果
  }
  /*輸出
  a--->[0 2 0 0 0]
  p--->[0 0 0 0 0]
  p--->&[0 2 0 0 0]
  */
   
  

• 支持多維數組:

  //多維數組：類似python中的嵌套數列
  package main
  import "fmt"
  func main() {
      a := [2][3]int{
          {1, 1, 1},
          {2, 2, 2}} //大括號必須放在數組結束的同一層
      fmt.Println(a)
  
      b := [...][3]int{ //當不知道到底是幾維數組時，可以使用...,但是，元素個數不可以使用...
          {1: 2}, //一維數組，第2個元素為2
          {2: 1}} //二維數組：第三個元素為1
      fmt.Println(b)
  
      c := [...][4]int{
          {3: 3},
          {1: 0},
          {2: 2}}
      fmt.Println(c)
  }
  
  /*輸出
  a--->   [[1 1 1] [2 2 2]]
  b--->   [[0 2 0] [0 0 1]]
  c--->   [[0 0 0 3] [0 0 0 0] [0 0 2 0]]
  */

• go實現冒泡排序:

  //冒泡排序
  package main
  import "fmt"
  
  func main() {
      a := [...]int{5, 2, 3, 1, 6, 8}
      fmt.Println(a)
      num := len(a)
      for i := 0; i < num; i++ {
          for j := i + 1; j < num; j++ {
              if a[i] < a[j] {
                  //temp := a[i]
                  a[i] = a[j]
                  a[j] = a[i] //temp
              }
          }
      }
      fmt.Println(a)
  }
  
  /*輸出結果
  a--->   [5 2 3 1 6 8]
  a--->   [8 6 5 3 2 1]  //從大到小排序
  */

  代碼解釋如下(6-14行)：

  1. 定義一個一維數組，並確定每個元素的值
  2. 輸出原始數組
  3. 通過len函數確定數組的長度 num
  4. for 循環，從0開始遍歷數組的每一個索引，直到遍歷完最後一個元素
  5. 從數組的第二個索引開始遍歷，直到遍歷完所有的元素
  6. 通過索引取值，比較相鄰兩個元素的大小，如果後一個元素的值大於前一個索引值（倒序）
  7. 將前一個元素的值賦值給變量temp(臨時值)
  8. 將數組前一個元素的值與後一個元素的值互換位置
  9. 遍歷完所有的元素後，最大的值是第一個元素

golang基礎--Array數組