GO 笔记-数组

数组

package main

import "fmt"

//数组
//必须制定存放的元素的类型和容量（长度）
//数组的长度是数组类型的一部分
func main() {
    var a1 [3]bool                 //[true false true]
    var a2 [4]bool                 //[true false true false]
    a1 = [3]bool{true, true, true} //初始化数组
    //根据初始化值自动腿短数组的长度是多少
    a3 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    //根据索引方式来初始化
    a4 := [5]int{0: 1, 4: 2}
    fmt.Println(a1, a2, a3, a4)
    //数组的遍历
    citys := [...]string{"北京", "上海", "广州", "深圳"}
    for i, v := range citys {
        fmt.Println(i, v)
    }

    //多维数组
    all := [3][10]int{
        {0, 1, 2, 3},   /*  第一行索引为 0 */
        {4, 5, 6, 7},   /*  第二行索引为 1 */
        {8, 9, 10, 11}, /* 第三行索引为 2 */
    }
    fmt.Println(all)
}

切片

1. 切片指向了一个底层的数组
2. 切片的长度就是它元素的个数
3. 切片的容量是底层数组从切片的第一个元素到最后一个元素的数量

package main

import "fmt"

func main() {

    //切片的定义
    var s1 []int    //定义一个存放int 类型元素的切片
    var s2 []string //顶一个存放string 类型的元素的切片
    fmt.Println(s1, s2)
    //初始化
    s1 = []int{1, 2, 3}
    s2 = []string{"中国", "美国", "日本"}
    fmt.Println(s1, s2)
    //由数组得到切片
    a1 := [...]int{1, 8, 3, 5, 6, 8, 56, 85}
    s3 := a1[0:3] //基于一个数组切割，左包含，右不包含（左闭右开） 注意跟定义数组key对应的值的区别
    fmt.Println(s3)
    s4 := a1[:4] //[0:4]
    s5 := a1[3:] //[3:len(al)]
    s6 := a1[:]  //[0:len(al)]
    fmt.Println(s4, s5, s6)
}

package main

import "fmt"

func main() {
    a1 := make([]int, 5, 10)
    fmt.Printf("a1=%v len(a1)=%d cap(a1)=%d\n", a1, len(a1), cap(a1))

    //切片就是一个框，框柱了一块连续的内存，属于引用类型，真正的数据都是保存在底层数组里的
    //切片之间不能比较的，我们不能使用== 操作符来判断两个切片是否含有全部相等元素，切片唯一合法的比较操作是喝nil比较
    //一个nil值得切片并没有底层数组，一个nil值得切片长度和容量都是0，但是我们不能说一个长度和容量都是0的切片一定是nil,
    //例如
    var s1 []int
    s2 := []int{}
    s3 := make([]int, 0)
    fmt.Println(s1, s2, s3)
    //判断切片是否是空的 需要用len() == 0 来判断 ，不应该使用s ==nil来判断
    //切片的赋值
    a2 := []int{1, 2, 3, 6}
    a3 := a2
    fmt.Println(a2, a3) //[1000 2 3 6]
    a3[0] = 1000
    fmt.Println(a2, a3) //[1000 2 3 6]
}

append()

package main

import "fmt"

func main() {
    //append()为切片追加元素
    s1 := []string{"北京", "上海", "深圳"}
    fmt.Printf("s1 = %v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
    //调用append 函数必须要用原来的切片变量接收返回值
    s1 = append(s1, "广州") //append 追加元素，原来的底层数组放不下的时候，go底层就会吧底层数组换一个地方
    fmt.Printf("s1 = %v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
    s1 = append(s1, "成都")
    fmt.Printf("s1 = %v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))

    ss := []string{"武汉", "西安", "重庆"}
    s1 = append(s1, ss...) //...表示拆开
    fmt.Printf("s1 = %v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))

}

copy() and 删除切片元素

package main

import "fmt"

func main() {
    a1 := []int{1, 5, 6, 9}
    a2 := a1 //赋值
    var a3 = make([]int, 3, 3)
    copy(a3, a1) //a1的值赋值到a3
    fmt.Println(a1, a2, a3)
    a1[0] = 100
    fmt.Println(a1, a2, a3)
    //将a1中的索引为1的3这个元素删掉
    //删除的原理是修改底层数组，用后面的值覆盖掉需要删除的值
    //1）切片不保存具体值
    //2）切片对应一个底层数组
    //3)底层数组都是占用一块连续的内存
    a1 = append(a1[:1], a1[2:]...)
    fmt.Println(a1)
}

指针

package main

import "fmt"

func main() {
    //go 语言中不存在操作指针
    //1. & 取地址

    n := 18
    p := &n
    fmt.Println(p) //0xc00000c1a8

    //2.* 根据地址取值
    m := *p
    fmt.Println(m) //18

    var a1 *int //nil pointer
    var a2 = new(int) //初始化
    *a2 = 100

    //make 和 new的区别
    //1.make 和new 都是用来申请内存的
    //2.new 很少用，一般用来给基本数据类型申请内存，string,int 返回的是对应类型的指针（*string,*int）
    //3.make 是用来给slice ,map,chan申请内存的，make函数返回的是对应的这三个类型本身
}

本作品采用《CC 协议》，转载必须注明作者和本文链接