golang学习笔记之--Go语言内建容器

今天继续记录学习笔记，今天的笔记主题是Go语言内建容器

如果各位童鞋想要获得下面的源码，请搜索gzh：隔壁王小猿，关注后回复“Go语言基本语法”即可获得

数组

数组定义

var arr1 [5]int
arr2 := [3]int{1, 3, 5}
arr3 := [...]int{2, 4, 6, 8, 10}
var grid [4][5]int

数组遍历

        //数组的遍历
	for i := ; i < len(arr3); i++ {
		fmt.Println(arr3[i])
	}
	//获取下标
	for i := range arr3 {
		fmt.Println(arr3[i])
	}
	//获取下标和值
	for i, v := range arr3 {
		fmt.Println(i, v)
	}
	//获取值
	for _, v := range arr3 {
		fmt.Println(v)
	}

range

• go语言的range-意义明确、美观
• C++没有类似
• Java、Python 只能for each value 不能同时获取i、v

数组是值类型

• [10]int 和[20]int是不同类型
• 调用func（arr [10]int）会copy数组
• 可以用数组指针传值
• golang一般不这么用，用切片

切片

slice

• slice本身没有数据，是对底层array的一个view
• slice做为参数，修改值会影响原数组
• 示例1

	arr:=[...]int{,1,2,3,4,5,6,7,8,9}
	fmt.Println("arr[2:6] = ",arr[2:6])
	fmt.Println("arr[:6] = ",arr[:6])
	fmt.Println("arr[2:] = ",arr[2:])
	fmt.Println("arr[:] = ",arr[:])

输出

arr[2:6] =  [2 3 4 5]
arr[:6] =  [ 1 2 3 4 5]
arr[2:] =  [2 3 4 5 6 7 8 9]
arr[:] =  [ 1 2 3 4 5 6 7 8 9]

• 示例2

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

	updateslice(s1)
	fmt.Println("after update s1.")
	fmt.Println("arr[2:] = ", s1)
	fmt.Println("arr[:] = ", s2)

	updateslice(s2)
	fmt.Println("after update s2.")
	fmt.Println("arr[2:] = ", s1)
	fmt.Println("arr[:] = ", s2)
}

输出

arr[2:] =  [2 3 4 5 6 7 8 9]
arr[:] =  [ 1 2 3 4 5 6 7 8 9]
after update s1.
arr[2:] =  [100 3 4 5 6 7 8 9]
arr[:] =  [ 1 100 3 4 5 6 7 8 9]
after update s2.
arr[2:] =  [100 3 4 5 6 7 8 9]
arr[:] =  [100 1 100 3 4 5 6 7 8 9]

slice的resize与扩展

s := arr[2:6]
s = s[:3]
s = s[1:]
s = arr[:]

思考题，请给出下面s1和s2的值

arr := [...]int{, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]

• s1的值为[2 3 4 5]，s2的值[5 6]
• slice可以向后扩展，不可以向前扩展
• s[i]不可以超越len(s)，向后扩展不可以超越底层数组cap(s)
• 如果直接访问s1[5]会提示数组越界

slice添加元素

• 添加元素时如果超越cap，系统会重新分配更大的底层数组
• 每次重新分配底层数组的大小扩大到原来的两倍
• 由于值传递的关系，必须接收append的返回值
• S=append(s,val)
• 示例

        arr := [...]int{, 1, 2, 3, 4, 5, 6, 7}
	s1 := arr[2:6]
	s2 := s1[3:5]

	fmt.Printf("arr = %v, len(arr) = %d, cap(arr) = %d \n", arr, len(arr), cap(arr))
	fmt.Printf("s2 = %v, len(s2) = %d, cap(s2) = %d \n", s2, len(s2), cap(s2))


	s3 := append(s2, 10)
	s4 := append(s3, 11)
	s5 := append(s4, 12)
	s6 := append(s5, 13)
	s7 := append(s6, 14)

	fmt.Println("after append. ")
	fmt.Printf("arr = %v, len(arr) = %d, cap(arr) = %d \n", arr, len(arr), cap(arr))
	fmt.Printf("s2 = %v, len(s2) = %d, cap(s2) = %d \n", s2, len(s2), cap(s2))
	fmt.Printf("s3 = %v, len(s3) = %d, cap(s3) = %d \n", s3, len(s3), cap(s3))
	fmt.Printf("s4 = %v, len(s4) = %d, cap(s4) = %d \n", s4, len(s4), cap(s4))
	fmt.Printf("s5 = %v, len(s5) = %d, cap(s5) = %d \n", s5, len(s5), cap(s5))
	fmt.Printf("s6 = %v, len(s6) = %d, cap(s6) = %d \n", s6, len(s6), cap(s6))
	fmt.Printf("s7 = %v, len(s7) = %d, cap(s7) = %d \n", s7, len(s7), cap(s7))

输出

arr = [ 1 2 3 4 5 6 7], len(arr) = 8, cap(arr) = 8 
s2 = [5 6], len(s2) = 2, cap(s2) = 3 
after append. 
arr = [ 1 2 3 4 5 6 10], len(arr) = 8, cap(arr) = 8 
s2 = [5 6], len(s2) = 2, cap(s2) = 3 
s3 = [5 6 10], len(s3) = 3, cap(s3) = 3 
s4 = [5 6 10 11], len(s4) = 4, cap(s4) = 6 
s5 = [5 6 10 11 12], len(s5) = 5, cap(s5) = 6 
s6 = [5 6 10 11 12 13], len(s6) = 6, cap(s6) = 6 
s7 = [5 6 10 11 12 13 14], len(s7) = 7, cap(s7) = 12

slice创建

	var s []int
	for i := ; i < 20; i++ {
		//fmt.Println(s)
		printSlice(s)
		s = append(s, 2*i+1)
	}
	fmt.Printf("s = %v, len(s) = %d, cap(s) = %d ", s, len(s), cap(s))

	s1 := []int{2, 4, 6, 8}
	printSlice(s1)

	s2 := make([]int, 16)
	fmt.Println(s2)
	printSlice(s2)

	s3 := make([]int, 16, 32)
	fmt.Println(s2)
	printSlice(s3)

输出

len(s) = , cap(s) =  
len(s) = 1, cap(s) = 1 
len(s) = 2, cap(s) = 2 
len(s) = 3, cap(s) = 4 
len(s) = 4, cap(s) = 4 
len(s) = 5, cap(s) = 8 
len(s) = 6, cap(s) = 8 
len(s) = 7, cap(s) = 8 
len(s) = 8, cap(s) = 8 
len(s) = 9, cap(s) = 16 
len(s) = 10, cap(s) = 16 
len(s) = 11, cap(s) = 16 
len(s) = 12, cap(s) = 16 
len(s) = 13, cap(s) = 16 
len(s) = 14, cap(s) = 16 
len(s) = 15, cap(s) = 16 
len(s) = 16, cap(s) = 16 
len(s) = 17, cap(s) = 32 
len(s) = 18, cap(s) = 32 
len(s) = 19, cap(s) = 32 
s = [1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39], len(s) = 20, cap(s) = 32 len(s) = 4, cap(s) = 4 
[               ]
len(s) = 16, cap(s) = 16 
[               ]
len(s) = 16, cap(s) = 32

slice复制

	fmt.Println("Copy slice.")
	copy(s2, s1)
	fmt.Printf("s2 = %v, len(s2) = %d, cap(s2) = %d \n", s2, len(s2), cap(s2))

输出

Copy slice.
s2 = [2 4 6 8            ], len(s2) = 16, cap(s2) = 16

slice删除

        fmt.Println("Deleting element.")
	s2 = append(s2[:3], s2[4:]...)
	fmt.Printf("s2 = %v, len(s2) = %d, cap(s2) = %d \n", s2, len(s2), cap(s2))

	fmt.Println("Deleting top.")
	s2 = s2[1:]
	fmt.Printf("s2 = %v, len(s2) = %d, cap(s2) = %d \n", s2, len(s2), cap(s2))

	fmt.Println("Deleting tail.")
	s2 = s2[:len(s2)-1]
	fmt.Printf("s2 = %v, len(s2) = %d, cap(s2) = %d \n", s2, len(s2), cap(s2))

输出

Deleting element.
s2 = [2 4 6            ], len(s2) = 15, cap(s2) = 16 
Deleting top.
s2 = [4 6            ], len(s2) = 14, cap(s2) = 15 
Deleting tail.
s2 = [4 6           ], len(s2) = 13, cap(s2) = 15

map

map创建

       m := map[string]string{
		"name":    "ccmouse",
		"course":  "golang",
		"site":    "imooc",
		"quality": "notbad",
	}
	fmt.Println(m)

	m2 := make(map[string]int) //m2 = empty map
	var m3 map[string]int      //m3 = nil

	fmt.Println(m2)
	fmt.Println(m3)

输出

map[course:golang name:ccmouse quality:notbad site:imooc]
map[]
map[]

map遍历

       fmt.Println("key and value.")
	for k, v := range m {
		fmt.Println(k, v)
	}

	fmt.Println("only value.")
	for _, v := range m {
		fmt.Println(v)
	}

	fmt.Println("only key.")
	for k, _ := range m {
		fmt.Println(k)
	}

输出

key and value.
name ccmouse
course golang
site imooc
quality notbad
only value.
notbad
ccmouse
golang
imooc
only key.
course
site
quality
name

获取value值

	fmt.Println("Getting values")
	courseName := m["course"]
	fmt.Println("courseName = ",courseName)
	causeName := m["cause"]
	fmt.Println("causeName = ",causeName)

	if causeName,ok :=m["cause"] ;ok{
		fmt.Println("causeName = ",causeName)
	}else {
		fmt.Println("key 【causeName】 does not exists")
	}

输出

Getting values
courseName =  golang
causeName =  
key 【causeName】 does not exists

删除元素

	fmt.Println("Deleting element.")
	name, ok := m["name"]
	fmt.Println(name, ok)
	delete(m, "name")
	name, ok = m["name"]
	fmt.Println(name, ok)

输出

Deleting element.
ccmouse true
false

map总结

• 创建：make（map[string]int）
• 获取元素：m[key]
• Key不存在，获取value类型的初始值
• 用value，ok:=m[key]来判断是否存在key
• 用delete删除一个key
• Map的遍历
  • 使用range遍历key，或者key、value对
  • 不保证遍历顺序，如需顺序，需要手动对key排序
  • 手游交易使用len获得元素个数
• Map的key
  • Map使用哈希表，key必须可以比较是否相等
  • 除了slice、map、function的内建类型，都可以作为key
  • Struct类型如果不包含上述类型，也可以作为key
  • 不需要重写hashcode()，equals()等方法

字符串操作

rune：相当于go的char

• 使用range遍历pos，rune对
• 使用utf8. RuneCountInString(s)获取字符数量
• 使用len获取字节长度
• 使用[]byte获取字节
• 示例

        s := "Yes我爱你老婆！"
	fmt.Println(len(s))
	fmt.Printf("%s \n", s)
	fmt.Printf("%X \n", s)
	for _, b := range []byte(s) {
		fmt.Printf("%X  ", b)
	}
	fmt.Println("")
	for i, ch := range s {
		fmt.Printf("(%d - %x )", i, ch)
	}
	fmt.Println()
	fmt.Println("Rune count:", utf8.RuneCountInString(s))

	bytes := []byte(s)
	for len(bytes) >  {
		ch, size := utf8.DecodeRune(bytes)
		bytes = bytes[size:]
		fmt.Printf("%c - ", ch)
	}
	fmt.Println()
	for i, ch := range []rune(s) {
		fmt.Printf("%d %c \n", i, ch)
	}

输出

21
Yes我爱你老婆！ 
596573E68891E788B1E4BDA0E88081E5A986EFBC81 
59  65  73  E6  88  91  E7  88  B1  E4  BD  A0  E8  80  81  E5  A9  86  EF  BC  81  
(0 - 59 )(1 - 65 )(2 - 73 )(3 - 6211 )(6 - 7231 )(9 - 4f60 )(12 - 8001 )(15 - 5a46 )(18 - ff01 )
Rune count: 9
Y - e - s - 我 - 爱 - 你 - 老 - 婆 - ！ - 
0 Y 
1 e 
2 s 
3 我 
4 爱 
5 你 
6 老 
7 婆 
8 ！

其他字符串操作

• Strings包里面
• Fileds Split Join
• Contains Index
• ToLower ToUpper
• Trim TrimRight TrimLeft