《Go语言从入门到进阶实战》学习笔记：第三章容器

本章详细介绍数组、切片、映射，以及列表的增删改查的使用方法。

3.1 数组--固定大小的连续空间

1、声明数组

var 数组变量名 [元素数量]T

其中元素数量必须是编译时就确定的整型值，T可以为任意基本类型

例：

        //定义一个长度为3的string数组，数组名为team
        var team [3]string
	team[0]="hammer"
	team[1]="soldier"
	team[2]="mum"

	fmt.Println(team)

2、初始化数组

var team = [3]string{"hammer","soldier","mum"}
//“...”表示让编译器确定数组的大小
var team = [...]string{"hammer","soldier","mum"}

3、遍历数组

        var team = [3]string{"hammer","soldier","mum"}
	for k,v:=range team{
		fmt.Println(k,v)
	}

3.2切片--动态分配大小的连续空间

1、声明切片

var name []T

name 表示切片类型的变量名

T表示切片类型对应的元素类型

        //声明字符串切片
	var str_List []string
	//声明整型切片
	var num_List []int
	//声明一个空切片
	var num_List_Empty = []int{}
	//输出三个切片
	fmt.Println(str_List,num_List,num_List_Empty)
	//输出三个切片的大小
	fmt.Println(len(str_List),len(num_List),len(num_List_Empty))
	//切片判定空的结果
	fmt.Println(str_List == nil)
	fmt.Println(num_List == nil)
	fmt.Println(num_List_Empty == nil)

2、使用make()函数构造切片

格式

make([]T,size,cap)

T：切片元素类型

size：分配元素个数

cap：预分配元素数量，对size没有影响

3、append()函数为切片添加元素

切片容量的扩展规律按照容量的2倍数扩充。

        //一次添加一个元素，还可以添加多个或整个切片
        var numbers []int
	for i:=0;i<10 ;i++  {
		numbers=append(numbers,i)
		fmt.Printf("len:  %d  cap:  %d  pointer:  %p\n",len(numbers),cap(numbers),numbers)
	}

    //添加整个切片
    nums = append(nums,team...)

4、复制一个切片元素到另一个切片

内建的copy()函数

copy(dest_Slice, src_Slice []T)

src_Slice表示源切片

dest_Slice为复制的目标。

package main

import "fmt"

func main()  {
	//设置元素个数
	const element_Count=1000
	//预分配足够多的元素切片
	src_Data:=make([]int,element_Count)
	//将切片赋值
	for i:=0;i<element_Count ;i++  {
		src_Data[i]=i
	}
	//引用切片数据
	ref_Data:=src_Data
	//预分配足够多的元素切片
	copy_Data:=make([]int,element_Count)
	//将数据复制到切片中
	copy(copy_Data,src_Data)
	//修改原始数据的第一个元素
	src_Data[0]=999
	//打印引用切片的第一个元素
	fmt.Println(ref_Data[0])
	//打印复制切片的第一个和最后一个元素
	fmt.Println(copy_Data[0],copy_Data[element_Count-1])
	//复制原始数据从4-6
	copy(copy_Data,src_Data[4:6])
	for i:=0;i<element_Count ;i++  {
		fmt.Printf("%d ",copy_Data[i])
	}

}

5、从切片中删除元素

        //初始化一个切片
	seq:=[]string{"a","b","c","d","e"}
	//指定删除位置
	index:=2
	seq=append(seq[:index],seq[index+1:]...)
	fmt.Println(seq)

3.3映射(map)--建立事物关联的容器

map使用散列表(hash)实现。

定义：map[key_type]value_type。

key_type为键类型，value_type为键对应的值类型。

        scene:=make(map[string]int)
	scene["route"]=66
	fmt.Println(scene["route"])
	v:=scene["route2"]
	fmt.Println(v)
        //另一种方法
        m:=map[string]string{
		"W":"forward",
		"A":"left",
		"D":"right",
		"S":"backward",
	}

2、map遍历

        scene:=make(map[string]int)
	scene["route"]=66
	scene["brazil"]=4
	scene["china"]=960

	for k,v:= range scene{
		fmt.Println(k,v)
	}

3、删除键值对

delete(map,键)

4、并发环境中使用的map--sync.Map

package main

import (
	"fmt"
	"sync"
)

func main()  {
	var scene sync.Map
	//将键值对保存到sync.Map
	scene.Store("greece",9)
	scene.Store("london",1)
	scene.Store("egypt",20)
	//从sync.Map中根据键取值
	fmt.Println(scene.Load("london"))
	//根据键删除对应的键值对
	scene.Delete("london")
	//遍历所有sync.Map中的键值对
	scene.Range(func(k, v interface{}) bool {
		fmt.Println("iterate",k,v)
		return true
	})
}

3.4列表(list)--可以快速增删的非连续空间的容器

Go语言中列表使用container/list包来实现，内部实现原理是双链表。列表能够高效地进行任意位置的元素插入和删除操作。

1、初始化列表

New和声明两种方法。

New的方法：变量名:=list.New()

声明的方法： var 变量名 list.List

2、列表中插入元素

        l:=list.New()

	l.PushBack("fist")
	l.PushFront(66)

3、列表中删除元素

        l:=list.New()
	//尾部添加元素
	l.PushBack("cannon")
	//首部添加元素
	l.PushFront(67)
	//尾部添加后保存元素句柄
	element:=l.PushBack("fist")
	//在fist之后添加high
	l.InsertAfter("high",element)
	//在fist之前添加noon
	l.InsertBefore("noon",element)
	l.Remove(element)

4、遍历列表

        //遍历list
	for i:=l.Front();i!=nil ;i=i.Next()  {
		fmt.Println(i.Value)
	}