golang基础--Array数组

---

基本特性

• 格式： var Name [n]<type>,n>0 如： var a [10]int 表示，定义一个长度为10，元素类型为int性的数组

• 数组长度： 长度（len）也是数组类型的一部分，因此具有不同长度的数组为不同的类型。 如var a [2]int != var a [3]int

• 注意区分指向数组的指针和指针数组

  package main
  
  import "fmt"
  
  
  func main() {
  // 指向数组的指针：变量是指针
  a := [...]int{9:1}   //定义一个变量a的数组(长度为10,第10个元素为1）
  
  var p *[10]int = &a //定义一个p的变量，类型为指针
  
  //指针数组：变量是数组，元素是指针(内存地址)
  x, y := 1, 2
  b := [...]*int{&x, & y}
  
  fmt.Print(p)
  fmt.Print(b)
  }
  
  print (p)
  print (b)
  /*输出结果：
  p---> &[0 0 0 0 0 0 0 0 0 1]
  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. 遍历完所有的元素后，最大的值是第一个元素