第03天(复合类型)_02

06_为什么需要数组.go

package main //必须有个main包
import "fmt"
func main() {
    //  id1 := 1
    //  id2 := 2
    //  id3 := 3
    //数组，同一个类型的集合
    var id [50]int
    //操作数组，通过下标， 从0开始，到len()-1
    for i := 0; i < len(id); i++ {
        id[i] = i + 1
        fmt.Printf("id[%d] = %d\n", i, id[i])
    }
}

07_数组的基本使用.go

package main //必须有个main包

import "fmt"

func main() {
    //定义一个数组, [10]int和[5]int是不同类型
    //[数字]， 这个数字作为数组元素个数
    var a [10]int
    var b [5]int

    fmt.Printf("len(a) = %d, len(b) = %d\n", len(a), len(b))

    //注意：定义数组是，指定的数组元素个数必须是常量
    //n := 10
    //var c [n]int //err non-constant array bound n

    //操作数组元素，从0开始，到len()-1, 不对称元素，这个数字，叫下标
    //这是下标，可以是变量或常量
    a[0] = 1
    i := 1
    a[i] = 2 // a[1] = 2

    //赋值，每个元素
    for i := 0; i < len(a); i++ {
        a[i] = i + 1
    }

    //打印
    //第一个返回下标，第二个返回元素
    for i, data := range a {
        fmt.Printf("a[%d] = %d\n", i, data)
    }
}

08_数组的初始化.go

package main //必须有个main包
import "fmt"
func main() {
    //声明定义同时赋值，叫初始化
    //1、全部初始化
    var a [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println("a = ", a)
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("b = ", b)
    //部分初始化，没有初始化的元素，自动赋值为0
    c := [5]int{1, 2, 3}
    fmt.Println("c = ", c)
    //指定某个元素初始化
    d := [5]int{2: 10, 4: 20}
    fmt.Println("d = ", d)
}

09_二维数组的介绍.go

package main //必须有个main包

import "fmt"

func main() {
    //有多少个[]就是多少维
    //有多少个[]就用多少个循环
    var a [3][4]int

    k := 0
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            k++
            a[i][j] = k
            fmt.Printf("a[%d][%d] = %d, ", i, j, a[i][j])
        }
        fmt.Printf("\n")
    }

    fmt.Println("a = ", a)

    //有3个元素，每个元素又是一维数组[4]int
    b := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
    fmt.Println("b = ", b)

    //部分初始化，没有初始化的值为0
    c := [3][4]int{{1, 2, 3}, {5, 6, 7, 8}, {9, 10}}
    fmt.Println("c = ", c)

    d := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
    fmt.Println("d = ", d)

    e := [3][4]int{1: {5, 6, 7, 8}}
    fmt.Println("e = ", e)
}

10_数组比较和赋值.go

package main //必须有个main包

import "fmt"

func main() {
    //支持比较，只支持 == 或 !=, 比较是不是每一个元素都一样，2个数组比较，数组类型要一样
    a := [5]int{1, 2, 3, 4, 5}
    b := [5]int{1, 2, 3, 4, 5}
    c := [5]int{1, 2, 3}
    fmt.Println(" a == b ", a == b)
    fmt.Println(" a == c ", a == c)

    //同类型的数组可以赋值
    var d [5]int
    d = a
    fmt.Println("d = ", d)
}

11_随机数的使用.go

package main //必须有个main包

import "fmt"
import "math/rand"
import "time"

func main() {
    //设置种子， 只需一次
    //如果种子参数一样，每次运行程序产生的随机数都一样
    rand.Seed(time.Now().UnixNano()) //以当前系统时间作为种子参数

    for i := 0; i < 5; i++ {

        //产生随机数
        //fmt.Println("rand = ", rand.Int()) //随机很大的数
        fmt.Println("rand = ", rand.Intn(100)) //限制在100内的数
    }
}

12_冒泡排序.go

package main //必须有个main包

import "fmt"
import "math/rand"
import "time"

func main() {
    //设置种子， 只需一次
    rand.Seed(time.Now().UnixNano())

    var a [10]int
    n := len(a)

    for i := 0; i < n; i++ {
        a[i] = rand.Intn(100) //100以内的随机数
        fmt.Printf("%d, ", a[i])
    }
    fmt.Printf("\n")

    //冒泡排序，挨着的2个元素比较，升序（大于则交换）
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-1-i; j++ {
            if a[j] > a[j+1] {
                a[j], a[j+1] = a[j+1], a[j]
            }
        }
    }

    fmt.Printf("\n排序后:\n")
    for i := 0; i < n; i++ {
        fmt.Printf("%d, ", a[i])
    }
    fmt.Printf("\n")

}