golang 数组、切片、map 06

朱雀 2022-12-08 14:14 162阅读 0赞

1. close：主要用来关闭channel
    2. len：用来求长度，比如string、array、slice、map、channel
    3. new：用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
    4. make：用来分配内存，主要用来分配引用类型，比如chan、map、slice
    5. append：用来追加元素到数组、slice中
    6. panic和recover：用来做错误处理
    
    go get安装第三方包

### 数组  ###

/*
    数组
    长度固定的数据类型，元素类型都是一样的。数组在内存中是连续的存储空间，可以有效的提高cpu的执行效率。
    变量或者数组在定义时，如果没赋值，会设置默认值。
    整形：0
    string:""
    bool：false
    */
    func RunArray() {
    	//数组定义方式1
    	//var arrayValue1 [10]int
    	//fmt.Println(arrayValue1)
    	//
    	数组定义方式2，通过推算设置数组的长度
    	//arrayValue2 := [...]int{1, 2, 3, 4, 5}
    	//fmt.Println(arrayValue2)
    
    	//数组定义方式3, 第一百的位置参数是200，第300的位置参数是500，0开始所以共301长度
    	arrayValue3 := [...]int{100: 200, 300: 500}
    	fmt.Println(len(arrayValue3), arrayValue3)
    }
    
    /*
    go语言中数组是值类型
    下标0开始，长度由len()获取
    */
    func runArray2() {
    	//直接调用，不会在其他函数内改变值。（除非使用指针类型）
    	//直接传值，是拷贝数组调用。
    
    	arrayV1 := [10]int{1, 2, 3, 4}
    	changeArray1(arrayV1)
    	fmt.Println(arrayV1)
    	changeArrayPointer(&arrayV1)
    	fmt.Println(arrayV1)
    }
    
    //这里会直接拷贝数组传入
    func changeArray1(v1 [10]int) {
    	v1[1] = 100
    	v1[2] = 200
    }
    
    func changeArrayPointer(v1 *[10]int) {
    	v1[3] = 300
    	v1[4] = 400
    }
    
    /*
    二维数组
    */
    func runTwo() {
    	//1
    	var arrayTwo1 [4][2]int
    	fmt.Println(arrayTwo1)
    
    	//2
    	arrayTwo2 := [4][2]int{
       {1, 2}, {2, 3}, {3, 4}, {4, 5}}
    	fmt.Println(arrayTwo2)
    
    	//3 通过指定位置参数
    	arrayTwo3 := [4][2]int{2: {1, 2}, 3: {2, 3}}
    	fmt.Println(arrayTwo3)
    }

//数组
    func Array01()  {
    	lenN := len("12345678")
    	fmt.Println(lenN)
    
    	//数组
    	var a[5]int
    	a[1] = 1
    	a[2] = 2
    	//数组是值类型，因此改变副本的值，不会改变本身的值
    	arr2 := a
    	arr2[2] = 6
    	fmt.Println(arr2)
    	fmt.Println(a)
    
    	var arr3[5]int
    	modify1(arr3)
    	fmt.Println(arr3)
    	modify2(&arr3)
    	fmt.Println(arr3)
    
    	//初始化
    	var age1 = [5]int{1,2,3,4}
    	age2 := [...]int{1,2,3,4,5,6}
    	//多维数组
    	age3 := [2][5]int{
       {1,2,3,4},{6,5,4,3}}
    	fmt.Println(age1,age2,age3)
    }
    
    //值类型不能直接修改
    func modify1(arr [5]int){
    	arr[0] = 100
    }
    
    //直接修改指针
    func modify2(arr *[5]int){
    	(*arr)[0] = 100
    }

###  slice ###

/*
    切片（指向底层数组的指针、长度、容量）
    append() 添加元素
    称为动态数组，长度可改变
    引用类型
    遍历方式：for,for range
    获取长度len()，获取容量cap()
    切片内存超出上限时，重新设置底层数组，达到扩容目的
    */
    func RunSlice() {
    	//数组
    	arrayValue1 := [10]int{1, 2, 3, 4, 5, 6, 7}
    	//切片(值和地址，与上面底层数组保持一致)
    	sliceValue1 := arrayValue1[:] //全赋值
    	fmt.Println(sliceValue1)
    
    	//选取赋值
    	sliceValue2 := arrayValue1[:5] //这个容量还是10
    	sliceValue3 := arrayValue1[5:] //下标5以前的容量失去
    
    	fmt.Println(sliceValue2, len(sliceValue2), cap(sliceValue2))
    	fmt.Println(sliceValue3, len(sliceValue3), cap(sliceValue3))
    
    	//通过长度和容量创建切片
    	sliceValue4 := make([]int, 5, 6)
    	sliceValue4[3] = 6 //设置下标3值6
    	fmt.Println(sliceValue4)
    	sliceValue4 = append(sliceValue4, 66) //容量+1，对应位置值66
    	fmt.Println(sliceValue4)
    
    	//copy 把sliceValue4 对应的值覆盖过来。
    	//sliceValue4长度超出sliceValue5，全覆盖值
    	//sliceValue4长度小于sliceValue5，只改变sliceValue4长度以内的值
    	sliceValue5 := []int{1, 2, 3, 4, 5}
    	copy(sliceValue5, sliceValue4)
    	fmt.Println(sliceValue5)
    
    	changeV(sliceValue5)
    	fmt.Println(sliceValue5)
    }
    
    /*
    这里传递的是切片，它对应的底层数组是一致的，所以修改值，能直接生效
    */
    func changeV(val []int) {
    	val[1] = 1000
    	val[2] = 10000
    }

/*
    切片：
    切片是数组的一个引用，因此切片是引用类型
    切片的长度可以改变，因此，切片是一个可变的数组
    len()求长度
    cap可以求出slice最大的容量
    */
    func Slice01(){
    	arr := [...]int{1,2,3,4,5,6}
    	//数组转换为切片
    	slice1 := arr[2:5]
    	slice2 := arr[:5]
    	slice3 := arr[2:]
    	fmt.Println(slice1,slice2,slice3)
    	//去掉末尾
    	slice4 := slice3[:len(slice3) -1]
    	fmt.Println(slice4)
    
    	//make创建切片
    	makeSlice1 := make([]byte,5)
    	makeSlice1[1] = 2
    	fmt.Println(makeSlice1)
    	//append 会在切片长度外添加元素
    	makeSlice1 = append(makeSlice1, 5,6,7)
    	fmt.Println(makeSlice1)
    	//遍历
    	for _, v := range makeSlice1 {
    		fmt.Print(v)
    	}
    
    	//拷贝,产生新的切片（修改对原切片没影响）
    	s1 := []int{1,2,3,4,5}
    	s2 := make([]int, 10)
    	copy(s2, s1)
    	s2[2] = 6
    	fmt.Println(s1,s2)
    
    	//string底层就是一个byte的数组
    	str := "hello world"
    	fmt.Println(str[6:])
    	//修改字符串
    	s := []byte(str)
    	s[0] = 'm' //这里单引号 代表字符
    	str = string(s)
    	fmt.Println(str)
    }

func Sorth(){
    	//升序
    	ints := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
    	sort.Ints(ints)
    	fmt.Println(ints)
    
    	//降序
    	ints2 := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
    	sort.Sort(sort.Reverse(sort.IntSlice(ints2)))
    	fmt.Println(ints2) // [9 8 7 6 5 4 3 2 1 0]
    }

### map  ###

/*
    map 无序键值对数据类型,key不能重复
    map[key] = value
    切片，函数不能作为key
    引用类型，传递到其他函数，值被改变，本身值已经改变
    */
    func RunMap() {
    	//1
    	var mapV1 map[string]string
    	mapV1 = make(map[string]string)
    	mapV1["1"] = "666"
    	mapV1["6"] = "888"
    	fmt.Println(mapV1)
    
    	//2
    	mapV2 := map[string]int{"MMM": 1, "FFF": 2, "RRR": 3}
    	fmt.Println(mapV2)
    
    	var sortKeys []string
    	//遍历
    	for k, v := range mapV2 {
    		fmt.Println(k, v)
    		sortKeys = append(sortKeys, k)
    	}
    
    	//排序，这里是通过ascii 排序
    	sort.Strings(sortKeys)
    	fmt.Println(mapV2)
    }

/*
    map是引用类型
    */
    func Maph(){
    	//添加
    	mapa := map[string]string{"hello": "world"}
    	fmt.Println(mapa)
    
    	mapb := make(map[string]string, 10)
    	mapb["nnn"] = "mmm"
    	mapb["www"] = "qqq"
    	fmt.Println(mapb["nnn"])
    
    	//遍历
    	for k, v := range mapb {
    		fmt.Println(k,v)
    	}
    
    	//删除
    	delete(mapb, "www")
    	fmt.Println(mapb,len(mapb)) //获取长度
    
    	//赋值方式
    	items := make(map[int]int, 5)
    	for i := 0; i < 5; i++ {
    		items[i] = i
    	}
    	fmt.Println(items)
    }

### list 队列 ###

package main
    
    import (
    	"container/list"
    	"fmt"
    )
    
    /*
    func (e *Element) Next() *Element
    返回该元素的下一个元素，如果没有下一个元素则返回nil
    
    func (e *Element) Prev() *Element
    返回该元素的前一个元素，如果没有前一个元素则返回nil。
    
    func New() *List
    返回一个初始化的list
    
    func (l *List) Back() *Element
    获取list l的最后一个元素
    
    func (l *List) Front() *Element
    获取list l的第一个元素
    
    func (l *List) Init() *List
    list l初始化或者清除list l
    
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element
    在list l中元素mark之后插入一个值为v的元素，并返回该元素，如果mark不是list中元素，则list不改变。
    
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element
    在list l中元素mark之前插入一个值为v的元素，并返回该元素，如果mark不是list中元素，则list不改变。
    
    func (l *List) Len() int
    获取list l的长度
    
    func (l *List) MoveAfter(e, mark *Element)
    将元素e移动到元素mark之后，如果元素e或者mark不属于list l，或者e==mark，则list l不改变。
    
    func (l *List) MoveBefore(e, mark *Element)
    将元素e移动到元素mark之前，如果元素e或者mark不属于list l，或者e==mark，则list l不改变。
    
    func (l *List) MoveToBack(e *Element)
    将元素e移动到list l的末尾，如果e不属于list l，则list不改变。
    
    func (l *List) MoveToFront(e *Element)
    将元素e移动到list l的首部，如果e不属于list l，则list不改变。
    
    func (l *List) PushBack(v interface{}) *Element
    在list l的末尾插入值为v的元素，并返回该元素。
    
    func (l *List) PushBackList(other *List)
    在list l的尾部插入另外一个list，其中l和other可以相等。
    
    func (l *List) PushFront(v interface{}) *Element
    在list l的首部插入值为v的元素，并返回该元素。
    
    func (l *List) PushFrontList(other *List)
    在list l的首部插入另外一个list，其中l和other可以相等。
    
    func (l *List) Remove(e *Element) interface{}
    如果元素e属于list l，将其从list中删除，并返回元素e的值。
    */
    func main() {
    	// 创建一个链表
    	alist := list.New()
    
    	fmt.Println("Size before : ", alist.Len())
    
    	//向链表中添加元素
    	alist.PushBack("a")
    	alist.PushBack("b")
    	alist.PushBack("c")
    
    	fmt.Println("Size after insert(push): ", alist.Len())
    
    	// 遍历
    	for e := alist.Front(); e != nil; e = e.Next() {
    		fmt.Println(e.Value.(string))
    	}
    
    	//移除元素
    	alist.Remove(alist.Front())
    	alist.Remove(alist.Front())
    	alist.Remove(alist.Front())
    
    	fmt.Println("Size after remove(pop) : ", alist.Len())
    }