Go语言基础03——复合类型

复合类型的分类

指针、数组、切片slice、字典map、结构体struct

指针

package main

import "fmt"

func main() {

    fmt.Println("指针使用演示案例")

    var a int
    a = 777
    fmt.Println("a = ", a)   //变量的内存
    fmt.Println("&a = ", &a) //变量的地址

    // 1. 指针的基本使用
    var p *int
    p = &a
    fmt.Printf("a的地址：%v,a的值：%v\n", p, *p) //a的地址：0xc00000a0c0,a的值：777

    *p = 666
    fmt.Println("a = ", a)

    // 2. 不要操作没有合法指向的内存
    p = nil
    // *p = 88 //err,panic: runtime error: invalid memory address or nil pointer dereference

    // 3. new函数的使用
    // 表达式new(T)将创建一个T类型的匿名变量，所做的是为T类型的新值分配并清零一块内存空间，
    //然后将这块内存空间的地址作为结果返回，而这个结果就是指向这个新的T类型值的指针值，返回的指针类型为*T。
    //我们只需使用new()函数，无需担心其内存的生命周期或怎样将其删除，因为Go语言的内存管理系统会帮我们打理一切。
    p = new(int)
    fmt.Printf("p的地址：%v,p的值：%v\n", p, *p) //p的地址：0xc00000a0e0,p的值：0

    // 4. 地址传递-交换两个数的值
    i, j := 3, 4
    fmt.Printf("i的值：%v,j的值：%v\n", i, j)
    swap(&i, &j)
    fmt.Printf("交换后，i的值：%v,j的值：%v\n", i, j)
}
func swap(a, b *int) {
    *a, *b = *b, *a
}

数组

数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。

数组⻓度必须是常量，且是类型的组成部分。 [2]int 和 [3]int 是不同类型。

package main

import "fmt"

func main() {

    fmt.Println("数组使用演示案例")

    var arr [10]int

    for i := 0; i < len(arr); i++ {
        arr[i] = i * i
    }
    for _, data := range arr {
        fmt.Println(data)
    }

    // 1. 数组的初始化
    var n = 10
    //var arr1 [n]int //err, non-constant array bound n

    const n1 = 10
    var arr3 [n1]int //ok

    fmt.Println(n, arr3)

    var arr4 [5]int = [5]int{1, 2, 3, 4, 5} // 全部初始化
    fmt.Println("arr4 = ", arr4)
    var arr5 [5]int = [5]int{1, 2, 3} // 部分初始化
    fmt.Println("arr5 = ", arr5)
    var arr6 [5]int = [5]int{1: 77, 2: 88} //指定元素初始化
    fmt.Println("arr6 = ", arr6)

    // 2. 二维数组

    var aa [3][4]int
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            aa[i][j] = i + j
        }
    }
    fmt.Println("aa = ", aa)

    bb := [3][4]int{{1, 2, 3, 4}, {4, 3, 2, 1}, {3, 3}}
    fmt.Println("bb = ", bb)
    // 多维数组的部分初始化
    cc := [3][4]int{1: {4, 3, 2, 1}}
    fmt.Println("cc = ", cc)

    // 3. 数组的比较和赋值
    //相同类型的数组之间可以使用 == 或 != 进行比较，但不可以使用 < 或 >，也可以相互赋值：

    var x1 [5]int = [5]int{1, 2, 3, 4, 5}
    var x2 [5]int = [5]int{1, 2, 3, 4, 5}
    var x3 [3]int = [3]int{1, 2, 3}
    fmt.Println("x1 == x2 ? ", x1 == x2) //err, invalid operation: x1 == x3 (mismatched types [5]int and [3]int)
    fmt.Println("x1 == x3 ? ", x1 == x3) //err, invalid operation: x1 == x3 (mismatched types [5]int and [3]int)

    xx1 := [5]int{1, 2, 3, 4, 5}
    xx2 := [5]int{1, 2, 3, 4, 5}

    fmt.Println("xx1 == xx2 ? ", xx1 == xx2) //true

}

随机数和冒泡排序

package main

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

func main() {

    fmt.Println("随机数和冒泡排序使用演示案例")
    // 1. 随机数
    rand.Seed(time.Now().UnixNano()) //以当前系统时间作为种子参数

    for i := 0; i < 5; i++ {
        v := rand.Int()    // 很大的随机数
        v = rand.Intn(100) // 100以内的随机数
        fmt.Println("v = ", v)
    }

    // 2. 冒泡排序

    var arr [10]int
    // 随机数初始化数组
    for i := 0; i < 10; i++ {
        arr[i] = rand.Intn(100)
    }
    fmt.Println("排序前 arr:", arr)
    //冒泡排序
    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < len(arr)-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }

    fmt.Println("排序后 arr:", arr)
}

数组做函数参数和数组指针做函数参数

package main

import "fmt"

func modify(arr [10]int) {
    arr[0] = 999
    fmt.Println("修改中 arr:", arr)
}
func modify2(p *[10]int) {
    (*p)[0] = 666 // 这里要注意一下
    fmt.Println("modify2 修改中 arr:", *p)
}

func main() {

    fmt.Println("随机数和冒泡排序使用演示案例")
    var arr [10]int
    for i := 0; i < 10; i++ {
        arr[i] = i
    }
    fmt.Println("修改前 arr:", arr)
    modify(arr)
    fmt.Println("修改后 arr:", arr)

    modify2(&arr)
    fmt.Println("modify2 修改后 arr:", arr)
}

切片

根据内存和性能来看，在函数间传递数组是一个开销很大的操作。在函数之间传递变量时，总是以值的方式传递的。如果这个变量是一个数组，意味着整个数组，不管有多长，都会完整复制，并传递给函数。

数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。Go语言提供了数组切片（slice）来弥补数组的不足。

切片并不是数组或数组指针，它通过内部指针和相关属性引⽤数组⽚段，以实现变⻓⽅案。

slice并不是真正意义上的动态数组，而是一个引用类型。slice总是指向一个底层array，slice的声明也可以像array一样，只是不需要长度。

package main

import "fmt"

func main() {

    fmt.Println("切片使用演示案例")

    var arr1 [5]int = [5]int{1, 2, 3, 4, 5} //这是数组的定义和初始化
    arr2 := [...]int{1, 2, 3, 4}            // 这也是数组的定义和初始化
    fmt.Printf("%T,%T\n", arr1, arr2)       //[5]int,[4]int

    a := []int{1, 2, 3, 4, 5}                           //这是切片
    s := a[0:3:5]                                       //这是切片
    fmt.Printf("%T,%T\n", a, s)                         //[]int,[]int
    fmt.Printf("cap(s):%d len(s):%d\n", cap(s), len(s)) // 5,3

    s1 := a[1:3:5]
    fmt.Printf("cap(s1):%d len(s1):%d\n", cap(s1), len(s1)) // 4,2

    // 1. 切片的创建：
    //slice和数组的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。
    // 1.1 自动推到类型，同时初始化
    ss := []int{1, 2, 3, 4} //
    fmt.Println("ss=", ss)  //ss= [1 2 3 4]
    // 1.2 借助make函数，格式：make(切片类型，长度，容量)
    ss2 := make([]int, 5, 8)
    fmt.Println("ss2=", ss2)
    // 1.3 没有指定容量，则容量=长度
    ss3 := make([]int, 6) //注意：make只能创建slice、map和channel，并且返回一个有初始值(非零)。
    fmt.Println("ss3=", ss3)

    var ss4 []int //声明切片和声明数组差不多，只是少了长度，此时为nil
    ss5 := []int{}
    fmt.Println(ss4, ss5) //[] []

    //2. 切片截取

    slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("slice :", slice)
    //[low:hign:max]  len = hign-low cap = max-high
    d1 := slice[:]
    fmt.Printf("d1 len:%d,cap:%d,v:%v \n", len(d1), cap(d1), d1) //len:9,cap:9,v:[1 2 3 4 5 6 7 8 9

    data := d1[3]
    fmt.Println("data ", data) //4,操作某个元素和操作数组方式一样

    d2 := slice[3:6:7]
    fmt.Printf("d2 len:%d,cap:%d,v:%v \n", len(d2), cap(d2), d2) //len:3,cap:4,v:[4 5 6]

    d3 := slice[3:]
    fmt.Printf("d3 len:%d,cap:%d,v:%v \n", len(d3), cap(d3), d3) //len:6,cap:6,v:[4 5 6 7 8 9]

    d4 := slice[:6]
    fmt.Printf("d4 len:%d,cap:%d,v:%v \n", len(d4), cap(d4), d4) //len:6,cap:9,v:[1 2 3 4 5 6]

    // 3. 切片和底层数组关系
    slice1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    z1 := slice1[2:6]
    z1[1] = 666
    fmt.Println(z1, slice1) //[3 666 5 6] [1 2 3 666 5 6 7 8 9]

    z2 := z1[1:3]               //666 5
    z2[0] = 777                 //z2: 777 5  z1:3 777 5 6 sl:1 2 3 777 5 6 7 8 9
    fmt.Println(z1, z2, slice1) //[3 777 5 6] [777 5] [1 2 3 777 5 6 7 8 9]

    // 4. append函数的使用,append函数向 slice 尾部添加数据，返回新的 slice 对象

    z3 := []int{}
    fmt.Println(z3) //[]
    z3 = append(z3, 1)
    z3 = append(z3, 2) //[1 2]
    fmt.Println(z3)
    // 4.1 append函数会智能地底层数组的容量增长，一旦超过原底层数组容量，通常以2倍容量重新分配底层数组，并复制原来的数据：

    z4 := make([]int, 0, 1)
    fmt.Printf("z4 len:%d,cap:%d,v:%v \n", len(z4), cap(z4), z4) //z4 len:0,cap:1,v:[]

    for i := 0; i < 50; i++ {
        z4 = append(z4, i)
        fmt.Printf("len:%d,cap:%d \n", len(z4), cap(z4))
    }

    // 5. copy 的使用，函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准，两个 slice 可指向同一底层数组。

    //该函数主要是切片（slice）的拷贝，不支持数组
    //将第二个slice里的元素拷贝到第一个slice里，拷贝的长度为两个slice中长度较小的长度值
    src := []int{1, 2, 3}
    dest := []int{66, 77, 88, 99}
    copy(src, dest)
    fmt.Println(src, dest) //[66 77 88] [66 77 88 99]

    src1 := []int{1, 2, 3}
    dest1 := []int{66, 77, 88, 99}
    copy(dest1, src1)
    fmt.Println(src1, dest1) //[1 2 3] [1 2 3 99]

    // 6. 切片作为函数参数：值传递
    slice2 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    modify(slice2)

    fmt.Println(slice2) //[1 2 666 4 5 6 7 8 9]
}
func modify(s []int) {
    s[2] = 666
}

Map

Go语言中的map(映射、字典)是一种内置的数据结构，它是一个无序的key—value对的集合，比如以身份证号作为唯一键来标识一个人的信息。

package main

import "fmt"

func main() {

    fmt.Println("Map使用演示案例")

    // 1. map的创建

    var m1 map[int]string // 只是声明一个map，没有初始化，此时为nil
    fmt.Println("m1  = ", m1)
    // m1[1] = "java" //err,panic: assignment to entry in nil map

    m2 := map[int]string{}
    m3 := make(map[int]string)
    m4 := make(map[int]string, 10) // 第二个参数为指定容量

    m2[1] = "java"
    m3[1] = "c++"
    m4[1] = "go"

    fmt.Println("m2  = ", m2)
    fmt.Println("m3  = ", m3)
    fmt.Println("m4  = ", m4)

    // 2.  初始化

    // 自动类型推到
    m5 := map[int]string{1: "java", 2: "c++", 3: "go"}

    // 定义的时候初始化
    var m6 = map[int]string{1: "go", 2: "java", 3: "c++"}
    fmt.Println("m5  = ", m5)
    fmt.Println("m6  = ", m6)

    // 3. map的赋值
    m7 := map[int]string{1: "java", 2: "c++", 3: "go"}
    m7[2] = "python" //修改
    m7[4] = "html"   //追加
    fmt.Println("m7  = ", m7)
    m8 := make(map[int]string)
    m8[1] = "java" //赋值
    fmt.Println("m8  = ", m8)

    // 4. map的遍历
    m9 := map[int]string{1: "java", 2: "c++", 3: "go"}
    for k, v := range m9 {
        fmt.Println("m9-->", k, v)
    }
    for k := range m9 { //第二个返回值value可以省略
        fmt.Println("m9-->", k)
    }

    // 判断某个key所对应的value是否存在，第一个返回值是value（如果存在的话）
    v, ok := m9[2]
    fmt.Println("m9-->", v, ok) //m9--> c++ true
    v1, ok1 := m9[4]
    fmt.Println("m9-->", v1, ok1) //m9-->  false

    // 5. map的删除
    m10 := map[int]string{1: "java", 2: "c++", 3: "go"}
    delete(m10, 2) //删除key值为2的map
    fmt.Println("m10  = ", m10)
    delete(m10, 12) //删除key值为12的map，不会报错
    fmt.Println("m10  = ", m10)

    // 6. map做函数参数为引用传递
    m11 := map[int]string{1: "java", 2: "c++", 3: "go"}
    change(m11)
    fmt.Println("m11  = ", m11) //C:\Users\Ivy\Desktop\code>
}

func change(m1 map[int]string) {
    m1[2] = "python"
}

结构体

结构体是一种聚合的数据类型，它是由一系列具有相同类型或不同类型的数据构成的数据集合。每个数据成为结构体的成员

package main

import "fmt"

//定义一个结构体类型
type Student struct {
    id   int
    name string
    age  int
    sex  byte
    addr string
}

func main() {

    fmt.Println("结构体使用演示案例")

    // 1. 结构体普通变量初始化
    // 顺序初始化，每个成员必须初始化
    // var s1 Student = Student{1, "zz", 12, 'm'}//err, too few values in Student literal
    var s1 Student = Student{1, "zz", 12, 'm', "bj"}
    fmt.Println("s1 = ", s1)

    // 指定成员初始化
    s2 := Student{id: 2, name: "ls"} //没有初始化的成员自动赋值为0
    fmt.Println("s2 = ", s2)         //s2 =  {2 ls 0 0 }

    // 2. 结构体指针变量初始化

    var p1 *Student = &Student{2, "jack", 18, 'm', "sh"}
    fmt.Println("p1 = ", p1)   //p1 =  &{2 jack 18 109 sh}
    fmt.Println("&p1 = ", &p1) //&p1 =  0xc000006030
    fmt.Println("*p1 = ", *p1) //*p1 =  {2 jack 18 109 sh}

    p2 := &Student{3, "mike", 19, 'm', "wh"}
    fmt.Println("p2 = ", p2)   //p2 =  &{3 mike 19 109 wh}
    fmt.Println("&p2 = ", &p2) //&p2 =  0xc000006038
    fmt.Println("*p2 = ", *p2) //*p2 =  {3 mike 19 109 wh}

    // 3. 结构成员的使用:普通变量
    var s3 Student
    s3.id = 3                //成员操作使用.运算符。定义完就可以使用了，这个比较厉害
    fmt.Println("s3 = ", s3) //{3  0 0 }

    // 4.  结构体成员的使用：指针变量

    var s4 Student
    var s5 *Student
    s5 = &s4
    s5.id = 5
    s5.name = "cal"
    (*s5).addr = "sh"          // 通过指针操作成员 s5.addr 和(*s5).addr完全等价
    fmt.Println("*s5 = ", *s5) //*s5 =  {5 cal 0 0 sh}

    // 使用new申请一个结构体,先分配空间，在赋值

    s6 := new(Student)
    s6.name = "vi"
    fmt.Println("s6 = ", s6)   //s6 =  &{0 vi 0 0 }
    fmt.Println("*s6 = ", *s6) //*s6 =  {0 vi 0 0 }

    // 5.结构体比较和赋值
    //如果结构体的全部成员都是可以比较的，那么结构体也是可以比较的，
    //那样的话两个结构体将可以使用 == 或 != 运算符进行比较，但不支持 > 或 < 。

    s7 := Student{1, "zk", 'm', 18, "bj"}
    s8 := Student{1, "zk", 'm', 18, "bj"}
    s9 := Student{1, "zz", 'm', 18, "bj"}
    fmt.Println("s7 = s8", s7 == s8) //true
    fmt.Println("s7 = s9", s7 == s9) //false

    // 6. 结构体做函数参数：值传递
    s10 := Student{1, "zk", 18, 'm', "bj"}
    fmt.Println("before s10 = ", s10) //{1 zk 18 109 bj}
    change(s10)
    fmt.Println("after s10 = ", s10) //{1 zk 18 109 bj}

    changePoint(&s10)
    fmt.Println("after point s10 = ", s10) // {666 zk 18 109 bj}
}

func change(s Student) {
    s.id = 666
    fmt.Println("ing s = ", s)
}

func changePoint(s *Student) {
    s.id = 666
    fmt.Println("ing s = ", s)
}

go语言可见性规则验证

Go语言对关键字的增加非常吝啬，其中没有private、 protected、 public这样的关键字。

要使某个符号对其他包（package）可见（即可以访问），需要将该符号定义为以大写字母
开头。

如果想使用别的包的函数、结构体类型、结构体成员
函数名，类型名，结构体成员变量名，首字母必须大写，可见
如果首字母是小写，只能在同一个包里使用

END.