Golang: 内建容器的用法_Golang_

 package main import "fmt" func updateArr(arr *[5]int) { arr[0] = 100 } func updateArrThroughSlice(arr []int) { arr[0] = 100 } func main() { //创建一个数据 var arr [5]int arr2 := [5]int{1, 2, 3, 4, 5} //长度让编译器来数 arr3 := [...]int{1, 2, 3, 4, 5} //[0 0 0 0 0] [1 2 3 4 5] [1 2 3 4 5] fmt.Println(arr, arr2, arr3) //定义二维数组 4行5列 var arr4 [4][5]int //[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]] fmt.Println(arr4) //遍历数据 //for i:=0;i

 package main import "fmt" func updateSlice(s []int) { s[0] = 100 } func main() { arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7} //创建一个Slice s1 := arr[:] s2 := arr[2:6] fmt.Printf("s1:%v\ns2:%v\n", s1, s2) //改变Slice内部元素 updateSlice(s2) fmt.Println(s2) //ReSlice:对Slice再进行一次Slice操作 s3 := s1[:5] fmt.Println(s3) s3 = s3[:2] fmt.Println(s3) } 

 package main import "fmt" func updateSlice(s []int) { s[0] = 100 } func main() { arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7} fmt.Printf("arr=%v\n", arr) //Extending Slice 不能超过cap(s) s1 := arr[2:6] fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d\n", s1, len(s1), cap(s1)) s2 := s1[3:5] fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d\n", s2, len(s2), cap(s2)) // s[i]不能超过len(s) fmt.Printf("get Slice element:%v",s2[1]) //panic: runtime error: index out of range [2] with length 2 //fmt.Printf("get Slice element:%v",s2[2]) } 

 package main import "fmt" //查看操作系统怎么扩充Slice的cap func printSlice(s []int) { fmt.Printf("%v, len=%d, cap=%d\n", s, len(s), cap(s)) } func main() { arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7} //添加元素时如果超越cap,系统会重新分配更大的底层数组 //由于值传递的关系,必须接收append的返回值 // s = append(s,val) s1 := arr[2:] fmt.Printf("s1=%v\n", s1) s2 := s1[3:5] //[s1[3], s1[4]] 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) fmt.Printf("s3=%v, s4=%v, s5=%v\n", s3, s4, s5) // s4 and s5 no longer view arr fmt.Printf("arr=%v\n", arr) //创建一个Slice var s []int //Zero value for slice is nil for i := 0; i < 100; i++ { printSlice(s) s = append(s, i*2+1) } fmt.Println(s) } 

 package main import ( "fmt" ) //查看操作系统怎么扩充Slice的cap func printSlice(str string, s []int) { fmt.Printf("%s=%v, len=%d, cap=%d\n", str, s, len(s), cap(s)) } func main() { //初始化slice s1 := []int{2, 4, 6, 8} fmt.Println(s1) //[2 4 6 8] //创建一个len为16的Slice s2 := make([]int, 16) //创建一个len为10,cap为32的Slice s3 := make([]int, 10, 32) printSlice("s2", s2) //[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], len=16, cap=16 printSlice("s3", s3) //[0 0 0 0 0 0 0 0 0 0], len=10, cap=32 //拷贝Slice fmt.Println("Copying Slice") //dst src copy(s2, s1) printSlice("s2", s2) //[2 4 6 8 0 0 0 0 0 0 0 0 0 0 0 0], len=16, cap=16 //删除Slice中的元素 fmt.Println("Deleting element from slice") //删除下标为3的元素 //通过...append s2下标为4后的元素 s2 = append(s2[:3], s2[4:]...) printSlice("s2", s2) //删除头尾元素 fmt.Println("Popping from front") front := s2[0] s2 = s2[1:] fmt.Println(front) fmt.Println(s2) fmt.Println("Popping from back") tail := s2[len(s2)-1] s2 = s2[:len(s2)-1] fmt.Println(tail) fmt.Println(s2) } 

 package main import "fmt" func main() { //创建一个map //map中的key是无序的,是一个HashMap m := map[string]string{ "name": "Cocktail_py", "course": "golang", "site": "CSDN", "quality": "pretty well", } m2 := make(map[string]int) // m2 = empty map var m3 map[string]int // m3 == nil fmt.Println(m, m2, m3) fmt.Println("Traversing map") for k, v := range m { fmt.Println(k, v) } //map 操作 //获取元素:m[key] fmt.Println("Getting values") courseName, ok := m["course"] fmt.Println(courseName, ok) //当key不存在 if courName, ok := m["courName"]; ok { fmt.Println(courName) // Zero value } else { fmt.Println("key does not exist") } fmt.Println("Deleting values") delete(m, "name") name, ok := m["name"] fmt.Println(name, ok) } 

 /* 当前一个字符串,从左往后开始扫描,只要扫描一遍就可以,如果扫到X的位置,看到一个字母X应该怎么做呢 首先,记录一个start表示当前找到的最长不含有重复字符的子串的开始,保证start到X之前的子串是不含有重复字符的, 之后,需要查看从start到X-1这个位置之间有没有X,使用一个叫lastOccurred[x]记录X最后出现的位置在哪里,使用map会有三种情况:1.x重来没有出现过,或者x出现在start之前,若x出现在start之前,最长的子串+1; 2.lastOccurred[x]出现在start到X中间,更新start位置,start指向lastOccurred[x+1]的位置 */ package main import "fmt" func lengthOfNonRepeatingSubStr(s string)int { lastOccurred := make(map[byte]int) start := 0 maxLength := 0 //遍历字符串 go语言中char类型是使用了一种rune(32位)类型 for x, ch := range []byte(s){ //lastOccurred[ch]有可能不存在;若不存在出现0,会影响运算 if lastl, ok:= lastOccurred[ch];ok && lastl >= start{ start = lastl + 1 } //stat到i结束 if x-start + 1 > maxLength{ maxLength = x -start + 1 } lastOccurred[ch] = x } return maxLength } func main() { fmt.Println(lengthOfNonRepeatingSubStr("hellohello")) } 

 package main import ( "fmt" "unicode/utf8" ) func main() { //英文占一个字节,中文占三个字节 s := "yes我爱CSDN!" fmt.Println(len(s)) // 14 //%X十六进制,大写字符,每个字节两个字符 //796573E68891E788B14353444E21 fmt.Printf("%X\n",[]byte(s)) //%T 相应值的类型 //使用for range遍历字符串时，会默认将byte（int8）类型转化为rune（int32）类型，因为go采用UTF-8编码 可变长的编码 for _,b := range s{ fmt.Printf("%T %X\n",b,b) } for _,b := range []byte(s){ fmt.Printf("%T %X\n",b,b) } //打印字符的个数 fmt.Println("Rune count:",utf8.RuneCountInString(s)) bytes := []byte(s) fmt.Println(bytes) for len(bytes) > 0{ ch,size := utf8.DecodeRune(bytes) bytes = bytes[size:] //相应Unicode码点所表示的字符 fmt.Printf("%c",ch) } //获取第几个字符是谁 for i, ch := range []rune(s) { fmt.Printf("(%d %c) ", i, ch) } fmt.Println() } 

 //国际版 func lengthOfNonRepeatingSubStr(s string) int { lastOccurred := make(map[rune]int) start := 0 maxLength := 0 //遍历字符串 go语言中char类型是使用了一种rune(32位) //for i, ch := range s{ for i, ch := range []rune(s) { //lastOccurred[ch]有可能不存在;若不存在出现0,会影响运算 if lastI, ok := lastOccurred[ch]; ok && lastI >= start { start = lastI + 1 } //start到i结束 if i-start+1 > maxLength { maxLength = i - start + 1 } lastOccurred[ch] = i } return maxLength } 

 // src/container/heap.go type Interface interface { sort.Interface Push(x interface{}) // add x as element Len() Pop() interface{} // remove and return element Len() - 1. }

 // src/sort/ type Interface interface { Len() int Less(i, j int) bool Swap(i, j int) }

 Len() int {} // 获取元素个数 Less(i, j int) bool {} // 比较方法 Swap(i, j int) // 元素交换方法 Push(x interface{}){} // 在末尾追加元素 Pop() interface{} // 返回末尾元素

 // 初始化一个堆 func Init(h Interface){} // push一个元素倒堆中 func Push(h Interface, x interface{}){} // pop 堆顶元素 func Pop(h Interface) interface{} {} // 删除堆中某个元素，时间复杂度 log n func Remove(h Interface, i int) interface{} {} // 调整i位置的元素位置（位置I的数据变更后） func Fix(h Interface, i int){}

 // 返回一个链表对象 func New() *List {}

 // 返回链表的长度 func (l *List) Len() int {} // 返回链表中的第一个元素 func (l *List) Front() *Element {} // 返回链表中的末尾元素 func (l *List) Back() *Element {} // 移除链表中的某个元素 func (l *List) Remove(e *Element) interface{} {} // 在表头插入值为 v 的元素 func (l *List) PushFront(v interface{}) *Element {} // 在表尾插入值为 v 的元素 func (l *List) PushBack(v interface{}) *Element {} // 在mark之前插入值为v 的元素 func (l *List) InsertBefore(v interface{}, mark *Element) *Element {} // 在mark 之后插入值为 v 的元素 func (l *List) InsertAfter(v interface{}, mark *Element) lement {} // 移动e某个元素到表头 func (l *List) MoveToFront(e *Element) {} // 移动e到队
                
提示：
                    本文由神整理自网络，如有侵权请联系本站删除！
                    

                    本站声明： 

                    1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持； 

                    2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！
                
                

                

                                            
上一篇：Go标准容器之Ring的使用说明_Golang_
                                                                
下一篇：go类型转换及与C的类型转换方式_Golang_