Go——container包（list、ring、heap）

最新推荐文章于 2024-03-23 12:04:27 发布
最新推荐文章于 2024-03-23 12:04:27 发布
阅读量283 收藏
点赞数 1
分类专栏： Go 文章标签： golang list 链表 heap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/130660518
版权

简介

container为容器数据类型：该包包含了三个数据结构：

  • List：双向链表
  • Ring：循环链表，也就是环
  • Heap：堆

一、list

Element为节点：

type Element struct {
	next, prev *Element
	list *List
	Value interface{}
}

方法列表：

type Element
    func (e *Element) Next() *Element                                  
    func (e *Element) Prev() *Element                                   
type List                               
    func New() *List                                                    
    func (l *List) Back() *Element                                      
    func (l *List) Front() *Element                                     
    func (l *List) Init() *List                                         
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element  
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element  
    func (l *List) Len() int                                            
    func (l *List) MoveAfter(e, mark *Element)                          
    func (l *List) MoveBefore(e, mark *Element)                         
    func (l *List) MoveToBack(e *Element)                   
    func (l *List) MoveToFront(e *Element)                                      
    func (l *List) PushBack(v interface{}) *Element                              
    func (l *List) PushBackList(other *List)                                   
    func (l *List) PushFront(v interface{}) *Element                             
    func (l *List) PushFrontList(other *List)                                   
    func (l *List) Remove(e *Element) interface{}                       

func (l *List) Back() *Element
返回值：*Element，链表中最后一个节点的指针，如果链表长度为0，则为nil

func (l *List) Front() *Element
返回值：*Element，链表中第一个节点的指针，如果链表长度为0，则为nil

func (l *List) Init() *List
返回值：*List，初始化或者清空后的链表
功能说明: 初始化或者清空链表，该方法调用后，链表的长度为0

func (l *List) Len() int
返回值：int，链接中节点的个数
功能说明：获得链接中节点的个数

func (l *List) InsertAfter(value interface{}, mark *Element) *Element
参数列表：
- value：要插入的数据的内容
- mark：链表中的一个节点指针
返回值：*Element：被插入的节点指针，该节点的Value为数据内容
功能说明：把数据value插入到mark节点的后面，并返回这个被插入的节点。

func (l *List) InsertBefore(value interface{}, mark *Element) *Element
参数列表：
- value：要插入的数据的内容
- mark：链表中的一个节点指针
返回值：*Element：被插入的节点指针，该节点的Value为数据内容
功能说明：把数据value插入到mark节点的前面，并返回这个被插入的节点。

func (l *List) MoveToBack(e *Element)
参数列表：
- e：链表中的节点
功能说明：把节点e移到链表的末尾

func (l *List) MoveToFront(e *Element)
参数列表：
- e：链表中的节点
功能说明：把节点e移到链表的开头

func New() *List
返回值：*List：空链表的指针
功能说明:创建一个空链表，链表的长度为0，开头和末尾节点都是nil

func (e *Element) Next() *Element
返回值：*Element：链表中该节点的下一个节点元素的指针，如果该节点是最后一个节点，则返回nil
功能说明：获得该节点在链表中的下一个节点元素的指针，如果该节点是最后一个节点，则返回nil

func (e *Element) Prev() *Element
返回值：*Element：链表中该节点的上一个节点元素的指针，如果该节点是第一个节点，则返回nil
功能说明：获得该节点在链表中的上一个节点元素的指针，如果该节点是第一个节点，则返回nil

func (l *List) PushBack(value interface{}) *Element
参数列表：
- value：将被存到链表末尾的任意对象
返回值：*Element：被存到末尾的节点的指针
功能说明：把一个对象存到链表末尾，并返回这个节点

func (l *List) PushBackList(ol *List)
参数列表：
- ol：将被插入到链表l末尾的链表
功能说明：把一个链表存到链表末尾

func (l *List) PushFront(value interface{}) *Element
参数列表：
- value：将被存到链表开头的任意对象
返回值：*Element：被存到开头的节点的指针
功能说明：把一个对象存到链表开头，并返回这个节点

func (l *List) PushFrontList(ol *List)
参数列表：
- ol：将被插入到链表l开头的链表
功能说明：把一个链表存到链表开头

func (l *List) Remove(e *Element) interface{}
参数列表：
- e：将被删除的节点，该节点必须是属于链表l的
返回值：interface{}：被删除的节点的内容
功能说明：删除指定的节点，并返回这个节点的内容

示例：

func main() {
	list := list.New()
	two := list.PushBack(2)
	three := list.PushBack(3)
	one := list.PushFront(1)
	printList(list) // 1 2 3

	list.MoveToBack(one)    // 2 3 1
	list.MoveToFront(three) // 3 2 1
	printList(list)         // 3 2 1
	list.Remove(two)
	printList(list) //3 1

	list.InsertAfter(4, one)
	list.InsertBefore(5, three)
	printList(list) // 5 3 1 4

	println(list.Len())// 4
	list.Init()
	println(list.Len())// 0
}

//打印链表
func printList(l *list.List) {
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Printf("%d ", e.Value)
	}
	fmt.Printf("\n")
}

二、ring

Go中提供的ring是一个双向的循环链表，与list的区别在于没有表头和表尾，ring表头和表尾相连，构成一个环

方法列表：

type Ring
	func New(n int) *Ring
	func (r *Ring) Do(f func(interface{}))
	func (r *Ring) Len() int
	func (r *Ring) Link(s *Ring) *Ring
	func (r *Ring) Move(n int) *Ring
	func (r *Ring) Next() *Ring
	func (r *Ring) Prev() *Ring
	func (r *Ring) Unlink(n int) *Ring

func New(n int) *Ring
参数列表：
- n：环形双向链表的节点的个数
返回值：*Ring：空链表的指针
功能说明:创建一个有n个节点的环形双向链表

# func (r *Ring) Do(f func(interface{}))
参数列表：
- `f`：一个回调函数，该函数的参数为环形双向链表中的节点的`Value`字段值
功能说明：正向遍历环形双向链表，并对每个链表中的元素执行回调函数`f`，如果这个回调函数`f`会修改链表`r`，那这个回调函数的行为将不可确定

# func (r *Ring) Len() int
返回值：
- `int`：环形链表中元素的个数
功能说明:遍历环形双向链表来统计链表中的元素的个数

# func (r *Ring) Link(s *Ring) *Ring
参数列表：
- `s`：环形双向链表
返回值：`*Ring`：`s`和`r`相连前`r.Next()`的值，也是相连后`s.Next()`的值
功能说明:
- 把一个环形双向链表`s`与环形双向链表`r`相链接，链接后`r.Next()`为s，并返回相连前时`r.Next()`的值。`r`不能为空。
- 如果`s`和`r`不是同一个环形链表，则相连后，只产生一个环形链表，并返回相连前时`r.Next()`的值，也是相连后`s.Prev()`的值。
- 如果`s`和`r`是同一个环形链表，但`s != r`时，相连后，产生两个环形链表，其中一个是由`r`和`s`之间的节点构成（不包括`r`和`s`），返回值为相连前时`r.Next()`的值，即`r`和`s`之间的节点（不包括`r`和`s`）构成的环形链表的表头节点。
- 如果`s`和`r`是同一个环形链表，且`s == r`时，相连后，产生两个环形链表，其中一个是由`r`指向的节点构成的长度为1的环形链表，其他节点构成另一个环形链表，返回值为相连前时`r.Next()`的值，即其他节点构成的环形链表的表头节点。

参数列表：
- `n`：指针`r`在双向链表上移动的位置的个数。n>0时，为正向移动；反之为反向移动。
返回值：*Ring：移动结束后，指针`r`指向的节点
功能说明：指向节点`r`的指针，正向或者逆向移动`n % r.Len()`个节点，并返回这个指针移动后指向的节点。但是`r.Move(n)`不对改变r的值，`r`不能为空

# func (r *Ring) Next() *Ring
返回值： `*Ring`：指向下一个节点的指针
功能说明：获得指向下一个节点的指针

# func (r *Ring) Prev() *Ring
返回值：`*Ring`：指向上一个节点的指针
功能说明：获得指向上一个节点的指针

# func (r *Ring) Unlink(n int) *Ring
参数列表：
- `n`：要被移除的节点的数个
功能说明：从节点`r`的下一个节点（包含该节点）开始移除`n % r.Len()`个节点。如果`n % r.Len() == 0`，则链表不会有改变。`r`不能为空。

示例：

func main() {
	r := ring.New(10)
	for i := 0; i < 10; i++ {
		r.Value = i
		r = r.Next()
	}
	ringPrint(r) //0 1 2 3 4 5 6 7 8 9

	fmt.Println(r.Len()) //10

	fmt.Println(r.Next().Value) //1
	fmt.Println(r.Prev().Value) //9

	r5 := r.Move(4)
	fmt.Println(r5.Value) //4

	r5.Unlink(3)
	ringPrint(r5) //4 8 9 0 1 2 3 （5、6、7三个节点被删除）

	//link两个不同的环形链表
	linkDiffRing()

	// 如果两个链表是同一个链表，但是两个指针不是指这个链表中的节点时，即s != r时
	linkSameRing()

	// 如果两个链表是同一个链表，且两个指针指向这个链表中的同一个节点时，即s == r时
	linkSameElement()

}

func ringPrint(r *ring.Ring) {
	r.Do(func(v interface{}) {
		fmt.Printf("%d ", v)
	})
	fmt.Printf("\n")
}

func makeN(n int, begin int) *ring.Ring {
	r := ring.New(n)
	for i := begin; i < n+begin; i++ {
		r.Value = i
		r = r.Next()
	}
	return r
}

// Link两个不同的环形链表
func linkDiffRing() {
	r1 := makeN(5, 0)
	ringPrint(r1) //0 1 2 3 4

	r2 := makeN(5, 10)
	ringPrint(r2) //10 11 12 13 14

	r1.Link(r2)
	fmt.Println(r1.Value) // 输出：0

	ringPrint(r1) //0 10 11 12 13 14 1 2 3 4
}

// 如果两个链表是同一个链表，但是两个指针不是指这个链表中的节点时，即s != r时
func linkSameRing() {
	r1 := makeN(10, 0)
	ringPrint(r1) //0 1 2 3 4 5 6 7 8 9

	r2 := r1.Move(5)
	fmt.Println(r1.Value, r2.Value) //0 5

	r3 := r1.Link(r2)

	ringPrint(r1) //0 5 6 7 8 9
	ringPrint(r3) //1 2 3 4
}

// 如果两个链表是同一个链表，且两个指针指向这个链表中的同一个节点时，即s == r时
func linkSameElement() {
	r1 := makeN(10, 0)
	ringPrint(r1)         //0 1 2 3 4 5 6 7 8 9
	fmt.Println(r1.Value) // 输出：0

	r2 := r1.Link(r1)

	ringPrint(r1) //0
	ringPrint(r2) //1 2 3 4 5 6 7 8 9
}

3、heap

任何实现了heap.Interface接口的对象都可以使用heap包提供的方法对堆进行操作(堆是一个完全二叉树)。通过对heap.Interface中的Less方法的不同实现，来实现最大堆和最小堆。通常堆的数据结构为一个一维数组。

//heap.interface
type Interface interface {
	sort.Interface
	Push(x interface{}) 
	Pop() interface{} 
}

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

方法列表：

func Init(h Interface)
func Pop(h Interface) interface{}
func Push(h Interface, x interface{})
func Remove(h Interface, i int) interface{}
3.1、func Init(h Interface)

参数列表：

  • h：实现了heap.Interface接口的堆对象

功能说明：在对堆h进行操作前必须保证堆已经初始化（即符合堆结构），该方法可以在堆中元素的顺序不符合堆的要求时调用，调用后堆会调整为标准的堆结构，该方法的时间复杂度为：O(n)，n为堆h中元素的总个数。

type myHeap []int // 定义一个堆，存储结构为数组

// 实现了heap.Interface中组合的sort.Interface接口的Less方法
func (h *myHeap) Less(i, j int) bool {
	return (*h)[i] < (*h)[j]
}

// 实现了heap.Interface中组合的sort.Interface接口的Swap方法
func (h *myHeap) Swap(i, j int) {
	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
}

// 实现了heap.Interface中组合的sort.Interface接口的Push方法
func (h *myHeap) Len() int {
	return len(*h)
}

// 实现了heap.Interface的Pop方法
func (h *myHeap) Pop() (v interface{}) {
	*h, v = (*h)[:h.Len()-1], (*h)[h.Len()-1]
	return
}

// 实现了heap.Interface的Push方法
func (h *myHeap) Push(v interface{}) {
	*h = append(*h, v.(int))
}

// 按层来遍历和打印堆数据，第一行只有一个元素，即堆顶元素
func (h myHeap) printHeap() {
	n := 1
	levelCount := 1
	for n <= h.Len() {
		fmt.Println(h[n-1 : n-1+levelCount])
		n += levelCount
		levelCount *= 2
	}
}

func main() {
	data := [7]int{13, 25, 1, 9, 5, 12, 11}
	aheap := new(myHeap)
	// 用堆本身的Push方法将数组中的元素依次存入堆中
	for _, value := range data {
		aheap.Push(value)
	}

	// 此时堆数组内容为：13, 25, 1, 9, 5, 12, 11
	// 不是正确的堆结构
	aheap.printHeap()
	// 输出：
	//  [13]
	//  [25 1]
	//  [9 5 12 11]

	heap.Init(aheap) // 对堆进行调整，调整后为规范的堆结构

	fmt.Println(*aheap) // 输出：[1 5 11 9 25 12 13]
	aheap.printHeap()
	// 输出：
	//	[1]
	//	[5 11]
	//	[9 25 12 13]
}
3.2、func Pop(h Interface) interface{}

参数列表：

  • h：实现了heap.Interface的堆对象

返回值：

  • interface{}：堆顶的元素

功能说明：从堆h中取出堆顶的元素并自动调整堆结构。根据h的Less方法实现的不同，堆顶元素可以是最大的元素或者是最小的元素。该方法的时间复杂度为O(log(n))，n为堆中元素的总和。

func main() {
	data := [7]int{13, 25, 1, 9, 5, 12, 11}
	aheap := new(myHeap) // 创建空堆

	// 用heap包中的Push方法将数组中的元素依次存入堆中，
	// 每次Push都会保证堆是规范的堆结构
	for _, value := range data {
		heap.Push(aheap, value)
	}
	fmt.Println(*aheap) // 输出：[1 5 11 25 9 13 12]
	aheap.printHeap()
	// 输出：
	//  [1]
	//  [5 11]
	//  [25 9 13 12]

	// 依次调用heap包的Pop方法来获取堆顶元素
	for aheap.Len() > 0 {
		fmt.Printf("%d ", heap.Pop(aheap))
	}
	// 输出：1 5 9 11 12 13 25
}
3.3、func Push(h Interface, x interface{})

参数列表：

  • h：实现了heap.Interface的堆对象
  • x：将被存到堆中的元素对象

功能说明：把元素x存到堆中。该方法的时间复杂度为O(log(n))，n为堆中元素的总和。

func main() {
	data := [7]int{13, 25, 1, 9, 5, 12, 11}
	aheap := new(myHeap) // 此时是空堆

	// 用heap包中的Push方法将数组中的元素依次存入堆中，
	// 每次Push都会保证堆是规范的堆结构
	for _, value := range data {
		heap.Push(aheap, value)
		fmt.Printf("插入%d\n", value)
		aheap.printHeap()
		fmt.Println()
	}
	fmt.Println(*aheap)
	// 输出：
	//	插入13
	//	[13]
	//
	//	插入25
	//	[13]
	//	[25]
	//
	//	插入1
	//	[1]
	//	[25 13]
	//
	//	插入9
	//	[1]
	//	[9 13]
	//	[25]
	//
	//	插入5
	//	[1]
	//	[5 13]
	//	[25 9]
	//
	//	插入12
	//	[1]
	//	[5 12]
	//	[25 9 13]
	//
	//	插入11
	//	[1]
	//	[5 11]
	//	[25 9 13 12]
	//
	//	[1 5 11 25 9 13 12]

}
3.4、func Remove(h Interface, i int) interface{}

参数列表：

  • h：实现了heap.Interface的堆对象
  • i：将被移除的元素在堆中的索引号

返回值：interface{}：堆顶的元素
功能说明：把索引号为i的元素从堆中移除。该方法的时间复杂度为O(log(n))，n为堆中元素的总和。

func main() {
	data := [7]int{13, 25, 1, 9, 5, 12, 11}
	aheap := new(myHeap) // 创建空堆

	// 用heap包中的Push方法将数组中的元素依次存入堆中，
	// 每次Push都会保证堆是规范的堆结构
	for _, value := range data {
		heap.Push(aheap, value)
	}
	fmt.Println(*aheap) // 输出：[1 5 11 25 9 13 12]
	aheap.printHeap()
	// 输出：
	//  [1]
	//  [5 11]
	//  [25 9 13 12]

	value := heap.Remove(aheap, 2) // 删除索引号为2的元素（即数组中的第3个元素）
	fmt.Println(value)             // 输出：11
	aheap.printHeap()
	// 输出：
	//	[1]
	//	[5 12]
	//	[25 9 13]
}
吴声子夜歌
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Go语言入门教程】Go语言容器（container）_golang container
2301_82257383的博客
04-13 887
外链图片转存中…(img-duUGLygW-1712998733309)]
Go~Golong容器大集合, 包括Slice、Map、Heap、List、Ring
Shangxingya的博客
12-11 1295
文章目录前言Slice1.1 创建切片1.2 理解数组指针1.3 自动扩容1.4 字节切片1.5 copy()函数1.6 sort.slice()排序1.7 切片的坑Map2.1 声明&初始化2.2 常用操作2.2.1 长度和容量2.2.2 添加2.2.3 修改2..2.4 删除2.2.5 查看2.2.6 嵌套2.2.7 变量赋值2.3 Map底层原理剖析2.3.1 初始化2.3.2 写入数据2.3.3 读取数据2.3.5 修改数据2.3.6 扩容2.3.5 迁移翻倍扩容等量扩容2.4 Map的坑H
【Go语言入门教程】Go语言容器（container）
qq_41854911的博客
02-08 2641
文章目录其它语言中的容器Go语言数组详解Go语言数组的声明比较两个数组是否相等遍历数组——访问每一个数组元素Go语言多维数组简述Go语言切片详解从数组或切片生成新的切片1) 从指定范围中生成切片2) 表示原有的切片3) 重置切片，清空拥有的元素直接声明新的切片使用 make() 函数构造切片温馨提示Go语言append()为切片添加元素Go语言copy()：切片复制（切片拷贝） 转载于：http://c.biancheng.net/golang/container/ 变量在一定程度上能满足函数及代码要求。如
Go 使用 container/list 作为队列 简单示例
最新发布
Don_tknowwhat的博客
03-23 437
类型不要求链表中的每个元素类型一致，可以插入任意类型的元素到同一双向链表中。在取值的时候我们需要自己执行类型的断言转换。不过也足够了，因为其实其他容器的行为通通都可以用最简单的数组实现。当需要使用队列的时候，不一定要用。的，有时候只是想做简单的 BFS 而已，没必要使用有序性的数据结构，这时候就需要使用。自动打印出了值，可是很多时候我们需要声明变量去承接值，并在后续使用。的，普通队列直接从队尾入队的话，时间复杂度是。类型，这也是为什么 golang 的。注意到上述的例子使用。
Golang Container包用法解析
weixin_44336181的博客
01-27 333
快速使用container包
go语言的container库（包括堆、双向链表等）
qq_42696069的博客
06-23 547
go语言的container库，包括堆、双向链表等的使用
二项堆python实现——eager binomial heap
06-21
eager binomial heaps python实现。使用双向链表，make_heap, insert, merge, find_min, extractMin.
vue项目build打包时报错 “JavaScript heap out of memory” 的解决办法
01-08
今天在执行npm run build 的时候突然出现下面图片所示错误 这个错误的意思时内存溢出，为什么会内存溢出呢？ 原来 nodejs 默认限制了最大可使用的内存大小。 nodejs V8 引擎在 64 位机器上默认限制使用内存最大不...
go_fibanaccy_heap:Go Fibanacci 堆实现
06-29
###import "github.com/alonsovidales/go_fibanaccy_heap" 包 fibheap 提供了斐波那契堆实现： : 作者：Alonso Vidales 此源代码的使用受 BSD 风格的约束。 这些程序和文件的分发没有任何明示或暗示的保证。 ...
堆排序——heap-sort
04-09
void heap_sort(int A[],int length) { BUILD_MAX_HEAP(A,length); int i,middle; for(i=length-1;i>0;i--) { middle=A[0]; A[0]=A[i]; A[i]=middle; heap_size--; MAX_HEAPIFY(A,0); } }
HeapFile:该存储库包含两个Java文件
04-17
例如，如果指定的页面大小是4096，则生成的堆文件将是heap.4096，以运行此文件命令：java dbLoad -p <page> file.csv dbQuery-此文件包含用于在给定堆文件中搜索指定字符串的代码。 它为堆文件的每一页提供输出...
golang中container/list包中的坑
笔记
03-02 620
转载地址：golang中container/list包中的坑 - Go语言中文网 - Golang中文社区 golang中list包用法可以参看golang中container/list包用法_chenbaoke的专栏-CSDN博客_golang list 但是list包中大部分对于e *Element进行操作的元素都可能会导致程序崩溃，其根本原因是e是一个Element类型的指针，当然其也可能为nil，但是golang中list包中函数没有对其进行是否为nil的检查，变默认其非nil进行操作，所以这种
【转载】Go容器（数组Array、切片slice、映射map、列表list）
沙师弟专栏
11-26 1万+
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。因为数组的长度是固定的，所以在Go语言中很少直接使用数组。和数组对应的类型是切片，切片是可以增长和收缩的动态序列，功能也更灵活，但是想要理解切片工作原理的话需要先理解数组。slice 是一个包含 data、cap 和 len 的结构体；hash 是一个指向 hmap 结构体的指针；ch 是一个指向 hchan 结构体的指针。
Go 标准库-双向链表 (container/list) 源码解析
eight_eyes的博客
10-31 662
container/list双向链表解析 概述 container/list包实现了基本的双向链表功能，包括元素的插入、删除、移动功能。 链表 链表是一种非连续存储的容器，由多个节点组成，节点通过一些变量记录彼此之间的关系。列表有多种实现方法，如单链表、双链表等 列表的原理可以这样理解：假设 A、B、C 三个人都有电话号码，如果 A 把号码告诉给 B，B 把号码告诉给 C，这个过程就建立了一个单链表结构，如下图所示。 如果在这个基础上，再从 C 开始将自己的号码给自己知道号码的人，这样就形成了双链表结构，
golang：list
OceanStar的博客
03-22 1609
初始化列表 list 的初始化有两种方法：分别是使用 New() 函数和 var 关键字声明，两种方法的初始化效果都是一致的。 通过 container/list 包的 New() 函数初始化 list 变量名 := list.New() 通过 var 关键字声明初始化 list var 变量名 list.List 列表与切片和 map 不同的是，列表并没有具体元素类型的限制，因此，列表的元素可以是任意类型，这既带来了便利，也引来一些问题，例如给列表中放入了一个 interface{} 类型的值
golang中container/ring包用法
chenbaoke的专栏
11-11 5241
ring包实现了环形链表的操作。   type Ring  //Ring类型代表环形链表的一个元素，同时也代表链表本身。环形链表没有头尾；指向环形链表任一元素的指针都可以作为整个环形链表看待。Ring零值是具有一个（Value字段为nil的）元素的链表。 type Ring struct { Value interface{} // 供调用者使用，本包不会对该值进行操
【速查版】Go 标准库：container/list（双向链表）
alenliu's blog
08-26 334
https://pkg.go.dev/container/list 官方标准库文档整理，讲解示例代码说明如何使用。
Go标准容器之List
热门推荐
Cynhard的专栏
05-27 2万+
简介Go的标准包container中包含了常用的容器类型，包括conatiner/list，container/heap，container/ring。本篇介绍conatiner/list。conatiner/list实现了一个双向链表。使用起来与其他语言的动态列表非常相似，3秒钟便可入门。3秒钟入门package mainimport ( "container/list" "fmt
java 生成hprof_Java应用问题定位系列——4种常见生成Heap Dump(堆快照)的方法
06-09
好的，针对您的问题，下面是Java生成Heap Dump的4种常见方法： 1. 使用jmap命令生成Heap Dump： jmap命令可以生成一个Java进程的Heap Dump。可以使用以下命令生成Heap Dump文件： ``` jmap -dump:format=b,file=...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值