扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > GO >Golang: 内建容器的用法
  • 179

0
分享到

Golang: 内建容器的用法

2024-04-02 19:04:59 179人浏览 独家记忆
摘要

1.数组 数组是值类型 [10]int 和 [20]int是不同类型 调用func(arr [10]int)会拷贝数组 在Go语言中一般不直接使用数据 package main

1.数组

数组是值类型

[10]int 和 [20]int是不同类型

调用func(arr [10]int)会拷贝数组

在Go语言中一般不直接使用数据


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<len(arr3);i++{
	//	fmt.Println(arr3[i])
	//}
	for num, v := range arr2 {
		fmt.Printf("第%d个元素为:%d\n", num, v)
	}
	//数据是值类型,通过指针可以改变值的大小
	fmt.Println("update before")
	fmt.Println(arr2)
	updateArr(&arr2) //传入arr3的地址
	fmt.Println("update after")
	fmt.Println(arr2)
	
	//通过Slice改变数据
	fmt.Println("update before")
	fmt.Println(arr3)
	updateArrThroughSlice(arr3[:]) //传入Slice
	fmt.Println("update after")
	fmt.Println(arr3)
}

2.Slice(切片)

2.1 Slice的实现

Slice本身没有数据,是对底层array的一个view

在这里插入图片描述

Slice内部有个指针(ptr)指向开头的元素,Slice有长度(len),容量(cap);cap代表从指针(ptr)开始到数组(arr)末尾的长度,Slice在扩展的时候不能超过cap.


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)
}

2.2 Slice的扩展

s[i]不可以超越len(i),向后扩展不可以超过底层数组cap(s)

在这里插入图片描述


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])
}

2.2 Slice的其它操作

向Slice添加元素


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)
}

Slice的copy,添加,删除元素操作


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)
}

3.Map

3.1 Map的操作

创建: make(map[string]int)

获取元素:m[key]

key不存在时,获得Value类型的初始值

用value,ok := m[key]来判断是否存在key

用delete删除一个key

使用range遍历key,或者遍历key, value对

不保证遍历顺序,如需顺序,需手动对key排序

使用len获得元素个数


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)
}

3.2 Map的key

map使用哈希表,必须可以比较相等

除了Slice,map,function的内建类型都可以作为key

Struct类型不包含上述字段,也可作为key

3.3 Map的例题:寻找最长不含有重复字符的子串

在这里插入图片描述



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"))
}

4.rune

rune相当于go的char

使用range遍历pos,rune对

使用utf8.RuneCountlnString获得字符数量

使用len获得字节长度

使用[]byte获得字节


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()
}

4.1 Map的例题:寻找最长不含有重复字符的子串(国际版)


//国际版
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
}

补充：Golang 容器的学习与实践

Golang 提供了几个简单的容器供我们使用，本文在介绍几种 Golang 容器的基础上，实现一个基于 Golang 容器的LRU算法。

容器介绍

Golang 容器位于 container 包下，提供了三种包供我们使用，heap、list、ring. 下面我们分别学习。

heap

heap 是一个堆的实现。一个堆正常保证了获取/弹出最大（最小）元素的时间为log n、插入元素的时间为 log n.

Golang堆实现接口如下：


// 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.
}

heap 是基于 sort.Interface 实现的。


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

因此，如果要使用官方提供的 heap，需要我们实现如下几个接口：


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){}

list 链表

list 实现了一个双向链表，链表不需要实现 heap 类似的接口，可以直接使用。

链表的构造：


// 返回一个链表对象
  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到队尾
func (l *List) MoveToBack(e *Element) {}
// 移动e到mark之前
func (l *List) MoveBefore(e, mark *Element) {}
// 移动e 到mark 之后
func (l *List) MoveAfter(e, mark *Element) {}
// 追加到队尾
func (l *List) PushBackList(other *List) {}
// 将链表list放在队列前
func (l *List) PushFrontList(other *List) {}

我们可以通过 Value 方法访问 Element 中的元素。除此之外，我们还可以用下面方法做链表遍历：


// 返回下一个元素
func (e *Element) Next() *Element {}
// 返回上一个元素
func (e *Element) Prev() *Element {}
下面是队列的遍历的例子：
// l 为队列，
for e := l.Front(); e != nil; e = e.Next() {
  //通过 e.Value 做数据访问
}

ring 循环列表

container 中的循环列表是采用链表实现的。


// 构造一个包含N个元素的循环列表
func New(n int) *Ring {}
// 返回列表下一个元素
func (r *Ring) Next() *Ring {}
// 返回列表上一个元素
func (r *Ring) Prev() *Ring {}
// 移动n个元素 （可以前移，可以后移）
func (r *Ring) Move(n int) *Ring {}
// 把 s 链接到 r 后面。如果s 和r 在一个ring 里面，会把r到s的元素从ring 中删掉
func (r *Ring) Link(s *Ring) *Ring {}
// 删除n个元素 （内部就是ring 移动n个元素，然后调用Link)
func (r *Ring) Unlink(n int) *Ring {}
// 返回Ring 的长度，时间复杂度 n
func (r *Ring) Len() int {}
// 遍历Ring，执行 f 方法 （不建议内部修改ring）
func (r *Ring) Do(f func(interface{})) {}

访问 Ring 中元素，直接 Ring.Value 即可。

容器的使用

下面，我们通过 map 和 官方包中的双向链表实现一个简单的 lru 算法，用来熟悉golang 容器的使用。

LRU 算法 (Least Recently Used)，在做缓存置换时用的比较多。逐步淘汰最近未使用的 cache，而使我们的缓存中持续保持着最近使用的数据。


package main 
import "fmt"
import "container/list"
 
// lru 中的数据
type node struct {
  K, V interface{}
}
 
// 链表 + map
type LRU struct {
  list *list.List
  cacheMap map[interface{}]*list.Element
  Size int
}
 
// 初始化一个LRU
func NewLRU(cap int) *LRU {
  return &LRU{
    Size: cap,
    list: list.New(),
    cacheMap: make(map[interface{}]*list.Element, cap),
  }
}
 
// 获取LRU中数据
func (lru *LRU) Get(k interface{}) (v interface{}, ret bool) {
  // 如果存在，则把数据放到链表最前面
  if ele, ok := lru.cacheMap[k]; ok {
    lru.list.MoveToFront(ele)
    return ele.Value.(*Node).V, true
  }
  return nil, false
}
// 设置LRU中数据
func (lru *LRU) Set(k, v interface{}) {
  // 如果存在，则把数据放到最前面
  if ele, ok := lru.cacheMap[k]; ok {
    lru.list.MoveToFront(ele)
    ele.Value.(*Node).V = v // 更新数据值
    return
  }
  // 如果数据是满的，先删除数据，后插入
  if lru.list.Len() == lru.Size {
    last := lru.list.Back()
    node := last.Value.(*Node)
    delete(lru.cacheMap, node.K)
    lru.list.Remove(last)
  }  ele := lru.list.PushFront(&Node{K: k, V: v})
  lru.cacheMap[k] = ele
}

注意事项

上述的容器都不是 goroutines 安全的

1、上面的lr 也不是 goroutines 安全的

2、Ring 中不建议在 Do 方法中修改 Ring 的指针，行为是未定义的

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。如有错误或未考虑完全的地方，望不吝赐教。

您可能感兴趣的文档:

--结束END--

本文标题: Golang: 内建容器的用法

本文链接: https://lsjlt.com/news/125133.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Golang: 内建容器的用法
    1.数组 数组是值类型 [10]int 和 [20]int是不同类型 调用func(arr [10]int)会拷贝数组 在go语言中一般不直接使用数据 package main ...
    99+
    2024-04-02
  • 如何在Golang中使用内建容器
    今天就跟大家聊聊有关如何在Golang中使用内建容器，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。什么是golanggolang 是Google开发的一种静态强类型、编译型、并发型，...
    99+
    2023-06-14
  • 使用Golang SDK执行Docker容器内的命令
    学习知识要善于思考，思考，再思考！今天编程网小编就给大家带来《使用Golang SDK执行Docker容器内的命令》，以下内容主要包含等知识点，如果你正在学习或准备学习Golang，就都不要错过本文...
    99+
    2024-04-04
  • golang读取注释内容的两种方法
    在Go语言中，注释是一个重要的功能，一个良好的注释可以使代码更加易于理解和维护。但是，有时候我们需要在代码中读取注释。本文将介绍一些方法来实现这个目标。基本的注释读取方法在Go语言中，注释可以使用//和/ /来表示单行注释和多行注释。我们可...
    99+
    2023-05-14
  • Golang - 打印变量的内容
    从现在开始，我们要努力学习啦！今天我给大家带来《Golang - 打印变量的内容》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留...
    99+
    2024-04-04
  • golang读取文件内容的方法有哪些
    在 Golang 中，我们可以使用以下几种方法来读取文件的内容： 使用 ioutil 包中的 ReadFile 函数：使用 iou...
    99+
    2023-10-20
    golang
  • 如何使用golang中的os.Create函数创建新文件并写入内容
    如何使用golang中的os.Create函数创建新文件并写入内容在golang中，使用os.Create函数可以创建新文件，并且可以通过相关函数将内容写入文件中。下面将详细介绍如何使用os.Create函数，并给出相应的代码示例。首先，我...
    99+
    2023-11-18
    Golang 创建文件 osCreate
  • golang读取目录内的日志文件内容
    问题内容 我正在尝试读取目录内的所有日志文件，下面的代码能够读取文件名，但不能读取其内容。 控制台输出 ds-api-doc-.log false 2023/03/21 11:27:1...
    99+
    2024-02-06
  • 云服务器的搭建方案有哪些内容和方法
    选择合适的云服务器提供商 选择云服务器提供商时，需要考虑许多因素，如云服务器提供商的可靠性、安全性、性能、价格等。在选择云服务器提供商时，可以查看他们的客户评价、用户案例和口碑。 配置云服务器 配置云服务器需要对云服务器的硬件、软...
    99+
    2023-10-28
    服务器 方案 方法
  • Golang变量设置的内容有哪些
    本文小编为大家详细介绍“Golang变量设置的内容有哪些”，内容详细，步骤清晰，细节处理妥当，希望这篇“Golang变量设置的内容有哪些”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。一、变量类型在Golang中，...
    99+
    2023-07-05
  • 如何使用 Golang 将内容写入文件？
    如何在 go 中将内容写入文件？使用 os.openfile() 打开或创建文件，并返回一个 *os.file 对象用于写入。使用 io.writestring() 函数直接将字符串写入...
    99+
    2024-05-15
    golang 文件读写
  • shell之创建文件及内容的方法示例
    shell之创建文件夹： [root@vbox-nginx shell_command]# vi ./mkdir.sh #!/bin/sh parentDir="/media/sf_Project/self/sm...
    99+
    2022-06-04
    shell 创建文件 shell 创建文件夹
  • 无法让 Golang 库向控制器返回除 nil 之外的任何内容
    php小编百草为您介绍问题：Golang库无法向控制器返回除nil之外的任何内容的解决方法。在Golang开发中，控制器是处理请求的关键组件，但有时可能遇到无法返回除nil之外的内容的...
    99+
    2024-02-11
    golang开发
  • Android如何创建自己的内容提供器
    小编给大家分享一下Android如何创建自己的内容提供器，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！创建内容提供器的步骤前面已经提到过，如果想要实现跨程序共享数...
    99+
    2023-05-30
    android
  • 使用Dockerfile实现容器内部服务随容器自启动的方法
    目录1 Docker下载python2 搭建flask服务2.1 创建flask脚本2.2 创建gunicorn启动脚本3 制作镜像3.1 将mypython容器制作成镜像3.2 D...
    99+
    2024-04-02
  • 聊聊Golang反射注释的相关内容
    Golang是一种简洁而极具效率的编程语言，而它的反射机制更是为程序员提供了各种强大的工具。本文将介绍Golang反射注释的相关内容。首先，什么是反射？反射是 Golang 语言中提供的一种强大的机制，可以在运行时动态地获取和操作程序的对象...
    99+
    2023-05-14
  • 云服务器的常用内容
    1. 弹性计算实例 弹性计算实例是云服务器的基本组成部分，它提供了虚拟的计算资源，包括处理器、内存、存储和网络等。用户可以根据自己的需求选择不同规格的实例，如CPU核数、内存大小和存储容量等。 2. 操作系统 云服务器通常支持多种操作系统...
    99+
    2023-10-28
    常用 服务器 内容
  • 如何使用Spring Boot内嵌容器Undertow创建服务器
    这篇文章给大家分享的是有关如何使用Spring Boot内嵌容器Undertow创建服务器的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。Undertow是一个Web服务器，那么它就需要具备的现代Web服务器的基本...
    99+
    2023-05-30
    springboot undertow
  • CMS 内容审核策略：创建无懈可击的内容战略
    ...
    99+
    2024-04-02
  • 云服务器的搭建方案有哪些内容
    云服务器(Cloud Server)是一种提供计算资源的云计算服务,它通常由公共云计算服务商提供,如亚马逊、阿里云、微软等,以提供计算资源,如CPU、内存、存储等,并为用户创建虚拟机或容器来运行应用程序。 搭建一个云服务器需要以下步骤: ...
    99+
    2023-10-26
    服务器 方案 内容
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作