Go语言集合类型数据结构总结

（一） 数组

//go语言提供了哪些集合类型的数据结构， 数组、 切片(slice)、 map、list
	//数组 定义： var name [count]int
	var courses1 [3]string //courses类型， 数组 只有3个元素的数组
	//var courses2 [4]string
	//[]string 和 [3]string //这是两种不同的类型
	
	courses1[0] = "go"
	courses1[1] = "grpc"
	courses1[2] = "gin"

	fmt.Println(courses1)
	fmt.Printf("%T\r\n", courses1)
	fmt.Printf("%T", courses2)

1) 数组的初始化

	//1.
	courses1 := [3]string{"go", "grpc", "gin"}
	for _, value := range courses1 {
		fmt.Println(value)
	}
	数组的初始化 2
	courses2 := [3]string{2:"gin"}
	for _, value := range courses2 {
		fmt.Println(value)
	}

	数组的初始化 3
	courses3 := [...]string{"go", "grpc"}
	
	for i := 0; i<len(courses3); i++ {
		fmt.Println(courses3[i])
	}
	
	//for _, value := range courses3 {
	//	fmt.Println(value)
	//}
	
	courses4 := [...]string{"go", "grpc"}
	
	if courses3 == courses4 {
		fmt.Println("equal")
	}

2) 多维数组

	var courseInfo [3][4]string
	courseInfo[0] = [4]string{"go", "1h", "bobby", "go体系课"}
	courseInfo[1] = [4]string{"grpc", "2h", "bobby2", "grpc入门"}
	courseInfo[2] = [4]string{"gin", "1.5h", "bobby3", "gin高级开发"}

	fmt.Println(len(courseInfo))

	//for i := 0; i<len(courseInfo); i++ {
	//	for j:=0; j<len(courseInfo[i]); j ++ {
	//		fmt.Print(courseInfo[i][j] + " ")
	//	}
	//	fmt.Println()
	//}

for _, row := range courseInfo {
		fmt.Println(row)
	}

（二）切片

1）切片的3种初始化 ：

1：从数组直接创建 
//go折中， slice 切片 - 数组  弱化数组，又要增加功能，类型动态语言中list
	var courses []string
	fmt.Printf("%T\r\n", courses)
	// 原理
	courses = append(courses, "go")
	courses = append(courses, "grpc")
	courses = append(courses, "gin")
2：使用string{} 
allCourses := [5]string{"go", "grpc", "gin", "mysql", "elasticsearch"}
	courseSlice := allCourses[0:len(allCourses)] //左闭右开 [) python
	fmt.Println(courseSlice)

3: make
make 函数
	allCourses2 := make([]string, 3)
	allCourses2[0] = "c"
	allCourses2[1] = "c"
	allCourses2[2] = "c"
	fmt.Println(allCourses2)
	
	//没有指定切片大小的时候。只能用append
	var allCourses3 []string
	allCourses3 = append(allCourses3, "c")
	fmt.Println(allCourses3)

2）访问切片的元素：

访问单个， 访问多个
	//fmt.Println(courseSlice[1])
1. 如果只有start 没有end 就表示从start开始到结尾的所有数据

2. 如果没有start 有end 就表示从0到end之前的所有数据
	
3. 如果有start 没有有end
4. 有start 有end
	//fmt.Println(courseSlice[1:4])
	//fmt.Println(courseSlice[1:])
	//fmt.Println(courseSlice[:])

	//courseSlice := []string{"go", "grpc"}
	//courseSlice2 := []string{"mysql", "es", "gin"}
	//courseSlice = append(courseSlice, courseSlice2[1:]...)

3）如何删除切片中的元素

//courseSlice := []string{"go", "grpc", "mysql", "es", "gin"}
myslice := append(courseSlice[:2], courseSlice[3:]...)
fmt.Println(myslice)

courseSlice = courseSlice[:3]
fmt.Println(courseSlice)

4）如何复制slice中的元素

//复制 slice
courseSlice := []string{"go", "grpc", "mysql", "es", "gin"}
//courseSliceCopy := courseSlice
courseSliceCopy2 := courseSlice[:] //地址变化  不会真复制
fmt.Println(courseSliceCopy2)

var courseSliceCopy = make([]string, len(courseSlice))
copy(courseSliceCopy, courseSlice) //这才会复制
fmt.Println(courseSliceCopy)

fmt.Println("------------------------")
courseSlice[0] = "java"
fmt.Println(courseSliceCopy2)
fmt.Println(courseSliceCopy)

5）切片的底层原理：

sclice是值传递，但是指向原来数组，只有通过append()添加元素的时候，会创建新的slice

（三） map

1）map创建方式

//map是一个key  和 value  的无序集合，主要是查询方便 O(1)

var courseMap = map[string]string{
   "go":   "go工程师",
   "grpc": "grpc入门",
   "gin":  "gin深入理解",
}
//取值
fmt.Println(courseMap["grpc"])

//var couseMap =map[String]string   //nill map类型要设置值必须先初始化
var courseMap = make(map[string]string, 3) //make是内置函数，主要用于初始化slice map  channel   3）slice可以不初始化

//放值
courseMap["mysql"] = "mysql原理"
fmt.Println(courseMap)

2） map的遍历

//遍历
//for key, value := range courseMap {
// fmt.Println(key, value)
//}

//遍历的是key
for key := range courseMap {
   fmt.Println(key)
}

//判断元素是否存在
if _, ok := courseMap["java"]; !ok {
   fmt.Println("not in")
} else {
   fmt.Println("in")
}

//删除元素
delete(courseMap, "rpc")

• map不是线程安全的

（四） list

list是链表

空间不连续

链表和数组性能差异很大

插入方便，但是查找较慢

//var mylist list.List

mylist := list.New()

mylist.PushBack("go")
mylist.PushBack("grpc")
mylist.PushBack("mysql")

//正向遍历
for i := mylist.Front(); i != nil; i = i.Next() {
   fmt.Println(i.Value)
}
//反向遍历
for i := mylist.Back(); i != nil; i = i.Prev() {
   fmt.Println(i.Value)
}

//指定位置插入元素
i := mylist.Front()
for ; i != nil; i = i.Next() {
   if i.Next().Value.(string) == "grpc" {
      break
   }
}
mylist.InsertBefore("gin", i)

//删除元素
mylist.Remove(i)
 i != nil; i = i.Prev() {
   fmt.Println(i.Value)
}

//指定位置插入元素
i := mylist.Front()
for ; i != nil; i = i.Next() {
   if i.Next().Value.(string) == "grpc" {
      break
   }
}
mylist.InsertBefore("gin", i)

//删除元素
mylist.Remove(i)