go学习三

值传递只能改变函数内的变量的值，不能改变传递之前原来的变量的值

想要改变的话 需要传递参数的地址 test01( p *int) //这样 将变量的地址传过来 然后 在函数内

def func(p *int){

　　*p = 555
}
这样可以改变调用他的原来变量的值 

 

 

指针

（实际上就是存放变量的内存地址）

mian.go

package main

import "fmt"

func init() {
    fmt.Println("tish is main init")
}

func main() {
    var a int = 10
    fmt.Println(a)
    fmt.Printf("内存  %v \n", &a)
}

运行结果

tish is main init
10
内存  0xc000014120 

 

*p   指针类型

main.go

func main() {
    var a int = 10
    fmt.Println(a)
    fmt.Printf("内存  %v \n", &a)
    var p *int  //定义一个指针
    p = &a  //p的合法指向，指向  a 的内存地址，  
    fmt.Printf("zheshi %v he %v \n", p, &a)

    *p = 666  #此操作 等价于  a=666     *p= 666此操作的前提是 p =&a 记 p有合法指向
    fmt.Printf("zheshi %v he %v \n", *p, a)
}

运行结果

10
内存  0xc000014120 
zheshi 0xc000014120 he 0xc000014120 
zheshi 666 he 666 

new的使用

func main() {

    var p *int
    p = new(int) //可以这样直接new一个新的内存
    *p = 666
    fmt.Printf("zheshi %v he  %v\n", *p, p)
    f := new(int) //或者这样创建一个新的指针变量
    *f = 777
    fmt.Printf("zhehsi %v", *f)
}

运行结果

zheshi 666 he  0xc000014120
zhehsi 777

值传递 只是把值传递过去，所以原来的变量的值不变

 

运行结果

 

地址传递

 

运行结果

 数组类型

 

定义一个数组 括号中的值不同代表不同的类型

数组的初始化

二维数组

main.go

func main() {
    var a [3][4]int
    k := 0

    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            a[i][j] = k
            fmt.Println(a[i][j], i, j)
            k += 1

        }
    }
    fmt.Println(a)

}

 

打印结果

0 0 0

1 0 1

2 0 2

3 0 3

4 1 0

5 1 1

6 1 2

7 1 3

8 2 0

9 2 1

10 2 2

11 2 3

[[0 1 2 3] [4 5 6 7] [8 9 10 11]]

 多维数组的部分初始化

数组的比较和赋值

随机数

 

rand.Int() 会产生随机数很大的数

rand.Intn(N) 会产生限定在 N以内的数子 

 冒泡排序

数组做函数的参数 以下只是值传递（值拷贝），所以员来的数组中的值不会受影响

打印结果 外部的数组未受影响

 

 数组指针做函数参数 把原来数组的指针作为参数传递 此时在 函数内是对 指针指向的内存进行操作 所以 内外数组都受影响

运行结果

 

数组与切片的区别

数组： a := [5] int  //写了一个5  容量是写死的

切片   b := [] int   //切片是活的  可以通过append 无限的给他扩充

 

 切片

 

 

 

 

数组和切片的区别

切片的创建

切片的截取

切片和底层数组的关系

切片并对新切片数据进行修改会使原始数据修改

 

main.go

func main() {
    s1 := [9]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    s2 := s1[2:5]
    fmt.Println(s2) //[3 4 5]

    s2[1] = 666
    fmt.Println(s2) //[3 666 5]

    fmt.Println(s1) //[1 2 3 666 5 6 7 8 9]  切片并对切片得到的数据进行修改
    //会使原始数据发生变化
    s3 := s2[2:5] //s3 如此取值 实际也是在原s1数组基础上获取数据
    s3[2] = 777
    fmt.Println(s3) //[5 6 777]  /所以s3获取的数据是这些
    fmt.Println(s1) //[1 2 3 666 5 6 777 8 9]

}

append函数

package main

import (
    "fmt"
    // "runtime"
)

func main() {
    s := make([]int, 5)
    fmt.Println(s) //[0 0 0 0 0]   切片使用make的形式创建，并写好长度，为填入数据则默认是用0补齐
    s = append(s, 1, 2, 3)
    fmt.Println(s) //[0 0 0 0 0 1 2 3] //切片有append方法，数组没有
    s1 := [4]int{}
    fmt.Println(s1) //[0 0 0 0]

}

 

copy

切片做函数的参数

实际上是把地址靠过去，通过地址操作切片 （就是引用传递）效率很高

产生一个四位随机数

package main

import "fmt"

import "math/rand"
import "time"

func init() {
    fmt.Println("tish is main init")
}

func a(p *int) { //产生一个四位随机数
    rand.Seed(time.Now().UnixNano())
    var num int
    for {
        num = rand.Intn(10000)
        if num >= 1000 {
            break
        }
    }
    *p = num
}

func main() {
    var ccc int
    a(&ccc)
    fmt.Println(ccc)

}

 

map(字典)

 

 

Go 语言Map(集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义 Map

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

实例

下面实例演示了创建和使用map:

实例

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */ 
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }
}

以上实例运行结果为：

France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India  首都是 新德里
American 的首都不存在

---

delete() 函数

delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：

实例

package main

import "fmt"

func main() {
        /* 创建map */
        countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo","India": "New delhi"}

        fmt.Println("原始地图")

        /* 打印地图 */
        for country := range countryCapitalMap {
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        }

        /*删除元素*/ delete(countryCapitalMap, "France")
        fmt.Println("法国条目被删除")

        fmt.Println("删除元素后地图")

        /*打印地图*/
        for country := range countryCapitalMap {
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        }
}

以上实例运行结果为：

原始地图
India 首都是 New delhi
France 首都是 Paris
Italy 首都是 Rome
Japan 首都是 Tokyo
法国条目被删除
删除元素后地图
Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhi

 map 特点首先它是个mutable的，也就是说，可以随时对其进行修改。其次，它不是线程安全的。

package main

import (
    "fmt"
    // "runtime"
)

func main() {
    m := make(map[string]int)
    m["aa"] = 1
    m["bb"] = 2
    m["cc"] = 3
    fmt.Println(m["aa"]) // 1
    fmt.Println(m["dd"]) // 0  如果没有此健值对则返回的是 0
    for key, val := range m {
        fmt.Println(key, val) //  aa 1   bb 2  cc 3

    }

}

下面的代码有什么问题?

type UserAges struct {
    ages map[string]int
    sync.Mutex
}

func (ua *UserAges) Add(name string, age int) {
    ua.Lock()
    defer ua.Unlock()
    ua.ages[name] = age
}

func (ua *UserAges) Get(name string) int {
    if age, ok := ua.ages[name]; ok {
        return age
    }
    return -1
}

考点：map线程安全
解答：
可能会出现fatal error: concurrent map read and map write. 修改一下看看效果

func (ua *UserAges) Get(name string) int {
    ua.Lock()
    defer ua.Unlock()
    if age, ok := ua.ages[name]; ok {
        return age
    }
    return -1
}

map 做函数参数

 

结构体

 

main.go

type Student struct {
    id   int
    name string
    sex  byte //字符类型
    age  int
    addr string
}

func main() {
    var s1 Student
    s1 = Student{1, "ming", 'm', 11, "beijing"} //全部字段初始化
    fmt.Println(s1)                             //{1 ming 109 11 beijing}

    s2 := Student{name: "liming", addr: "dsf"} //指定成员初始化
    fmt.Println(s2)                            //{0 liming 0 0 dsf} //未初始化的字段 值默认未0

}

结构体指针变量初始化

main.go

package main

import "fmt"

type Student struct {
    id   int
    name string
    sex  byte //字符类型
    age  int
    addr string
}

func main() {
    var s1 *Student                              //
    s1 = &Student{1, "ming", 'm', 11, "beijing"} //全部字段初始化 不要忘记加 &
    fmt.Println(s1)                              //{1 ming 109 11 beijing}
    fmt.Printf("type is %T \n", s1)              //type is *main.Student
    s2 := &Student{name: "liming", addr: "dsf"}  //指定成员初始化 自动推导类型
    fmt.Println(s2)
    fmt.Printf("type is %T \n", s2) //type is *main.Student

}

操作成员需要 . 运算符

结构体成员 使用指针变量

 

通过new生成一个结构体

同类型的结构体可以相互赋值

 字段内容相同的两个结构体 值相等

结构体做函数参数

值传递

地址传递

自定义结构体和自定义函数用于外部函数的引用时命名书写规则

test.go