go语言学习【六】

目录：
1.map
2.结构体
3.结构体中的方法

1.map

map是key-value数据结构，又称为字段或者关联数组。类似其它编程语言的集合。

var map变量名 map[keytype]valuetype
key类型通常为int,string
注意：slice,map,function不可以，因为这几个没法用==判断
valuetype类型通常为：数字（整数，浮点数）,string,map,struct
map声明案例：
var a map[string]string
var a map[int]string
注意：声明是不会分配内存的，初始化需要make，分配内存后才能赋值和使用。

var a map[string]string
//在使用map前，需要先make，make的作用就是给map分配数据空间
a = make(map[string]string,10)
a["name"]="张三"//输出结果：map[name:张三]
fmt.Println(a)

map的key是不能重复的，如果重复了，则以最后这个key-value为准。

• map使用的三种方式

//方式一
  var a map[string]string
  a=make(map[string]string,10)
  a["name"]="Marry"
  
  //方式二
  cities := make(map[string]string)
  cities["no1"]="北京"
  cities["no2"]="上海"
  cities["no3"]="赣州"
  

  //方式三
  names := map[string]string{
      "name1":"小明",
      "name2":"小花",
      "name3":"小李",
  }

• 演示一个key-value的value是map的案例

// 存放两个学生信息，每个学生有name,sex和address信息
package main
import "fmt"
func main(){
  students := make(map[string]map[string]string)
  students["01"]=make(map[string]string,3)
  students["01"]["name"]="tom"
  students["01"]["sex"]="男"
  students["01"]["address"]="rode1"

  students["02"]=make(map[string]string,3)
  students["02"]["name"]="Marry"
  students["02"]["sex"]="女"
  students["02"]["address"]="rode2"

  fmt.Println(students)
  fmt.Println(students["02"]["name"])//取出其中一个信息
}

输出结果：

map[01:map[address:rode1 name:tom sex:男] 02:map[address:rode2 name:Marry sex:女]]
Marry

• map的遍历

//对上述案例的遍历输出
for k1,v1 := range students {
       fmt.Printf("k1=%v\n",k1)
       for k2,v2 := range v1 {
           fmt.Printf("\t k2=%v v2=%v\n",k2,v2)
       }
    fmt.Println()
   }

k1=01
         k2=address v2=rode1
         k2=name v2=tom
         k2=sex v2=男

k1=02
         k2=name v2=Marry
         k2=sex v2=女
         k2=address v2=rode2

• map切片
  切片的数据类型是map，称为map切片，这样使用map的个数就可以动态变化了。

// 使用map来记录学生信息，name和age
// 一个学生对应一个map,并且学生的个数可以动态增加
package main
import "fmt"
func main(){
    var students []map[string]string
    students = make([]map[string]string,2) //切片本身需要make
    //增加第一个学生信息
     if students[0]==nil {
         students[0]=make(map[string]string,2)
         students[0]["name"]="Marry"
         students[0]["age"]="18"
    }
    //增加第二个学生信息
    if students[1]==nil {
        students[1]=make(map[string]string,2)
        students[1]["name"]="Jack"
        students[1]["age"]="20"
   }
   //使用切片的append函数，动态增加学生个数
   newstudent := map[string]string {
       "name":"新的学生Tom",
       "age":"16",
   }
   students = append(students,newstudent)
   fmt.Println(students)
}

[map[age:18 name:Marry] map[age:20 name:Jack] map[age:16 name:新的学生Tom]]

• map使用细节

1 map是引用类型，遵守引用类型传递的机制，
在一个函数接收map，修改后，会直接修改原
来的map
2 的容量达到后，再想map增加元素，会自
动扩容，并不会发生panic，也就是说map 能
动态的增长键值对(key-value)
3 map 的 value 也经常使用 struct 类型，更适合
管理复杂的数据 (
比前面 value 是一个 map 更
好),比如 value 为 Student 结构体

2.结构体

package main
import "fmt"
type Stu struct {//声明结构体
    name string
    sex string
    age int
}
func main() {
    var stu1 Stu
    stu1.name="Marry"
    stu1.sex="女"
    stu1.age=16
    fmt.Println("stu1=",stu1)//输出：stu1= {Marry 女 16}
}

注意：指针，切片，map声明后并没有分配空间，如需使用必须进行make分配空间。

• 创建结构体实例的四种方式

type Stu struct {
    name string
    age int
}
//方式一
p1.name="tom"
p1.age=16
//方式二
p2 := Stu{"Mary",20}
//方式三
var p3 *Stu=new(Stu)
(*p3).name="John" //结构体指针标准用法
(*p3).age=16
//方式四
var p4 *Stu = &Stu{"Bob",24}

3.结构体中的方法

Golang中的方法是作用在指定的数据类型上的（即和指定的数据类型绑定），因此自定义类型都可以有方法，而不仅仅是struct。

type A struct {
    Num int
}
func (a A)test() {
fmt.Println(a.Num) //表示A结构体有一方法，方法名为 test
//(a A)体现 test 方法是和 A 类型绑定的
}

入门案例：

package main
import "fmt"
//给person结构体添加speak方法为，输出 xxx是一个好人
type Person struct {
    Name string
}
func(p Person)speck() {
    fmt.Println(p.Name,"是一个好人")
}
//给person结构体添加jisuan方法，可以计算1+……+1000的结果
//说明方法体内可以和函数一样，进行各种运算
func(p Person)jisuan() {
    res := 0
    for i:=0;i<=1000;i++ {
        res+=i
    }
    fmt.Println("1+……+1000=",res)
}
//给person结构体添加getsum方法，可以计算两个数的和，并返回结果
func (p Person)getsum(n1 int,n2 int)int {
    return n1+n2
}
func main() {
    var p Person
    p.Name = "Mary"
    p.speck()
    p.jisuan()
    res := p.getsum(18,36)
    fmt.Println("res=",res)
}

输出结果：

Mary 是一个好人
1+……+1000= 500500
res= 54

方法的声明(定义)
func (recevier type)methodName（参数列表）（返回值列表）{
方法体
return 返回值
}
1）参数列表：表示方法输入
2）recevier type:表示这个方法和type这个类型进行绑定，或者说该方法作用于type类型
3) receiver type :type可以是结构体，也可以其它的自定义类型
4）receiver :就是type类型的一个变量，比如： Person结构体的一个变量
5）参数列表：表示方法输入
6）返回值列表：表示返回的值，可以多个
7）方法主体：表示为了实现某一功能代码块
8) return 语句不是必须的

下面是方法的练习题

package main
import "fmt"
type Method struct {
    //字段
}
// 1.编写一个方法，提供m和n两个参数，方法中打印一个m*n的矩形
func (t Method)print(m int,n int) {
    for i:=1;i<=m;i++ {
        for j:=1;j<=n;j++ {
            fmt.Print("*")
        }
        fmt.Println()
    }
}

// 2.编写一个方法计算矩形面积（可以接收长len,宽width）
// 将其作为方法返回值，在main方法中调用该方法，接收返回值并打印
func (t Method)area(len float64,width float64)float64 {
    return len*width
}
func main() {
     var t Method
     t.print(3,4)
     res := t.area(8.6,3.8)
     fmt.Println("面积=",res)
}

输出结果：

****
****
****
面积= 32.68

// 3.用一个方法实现加减乘除功能
package main
import "fmt"
type Cal struct {
    num1 float64
    num2 float64
}
func (cal *Cal)getRes(operate byte)float64 {
    res:=0.0
    switch operate {
    case '+':
        res=cal.num1+cal.num2
    case '-':
        res=cal.num1-cal.num2
    case '*':
        res=cal.num1*cal.num2
    case '/':
        res=cal.num1/cal.num2
    default:
        fmt.Println("运算符输入有误...")
    }
  return res
}
func main() {
    cal := Cal{8.6,6.0}
    res := cal.getRes('+')
    fmt.Println("运算结果=",res)
}
//输出结果：运算结果= 14.6