Golang入门 - 指针&切片(容器)

1.什么是指针

每个变量在运行时都拥有一个地址,这个地址代表变量在内存中的位置。Go语言中使用“&”操作符放在变量前面对变量进行“取地址”操作。
首先来看一下基本语法

func main() {
	i := 1
	str := "123"
	var ptr *int = &i
	fmt.Println(i, ptr, &i, str, &str)
}

在这里插入图片描述
在这里插入图片描述
输出值在每次运行是不同的,代表cat和str两个变量在运行时的地址。在32位平台上,将是32位地址;64位平台上是64位地址。

每个变量都拥有地址,指针的值就是地址。
再来几个例子:
首先我们得晓得一下:
fmt.Printf的一些参数
在这里插入图片描述

取指针内的值:

fmt.Println(*ptr)

在这里插入图片描述

func main() {
	i := 1
	str := "123"
	ptr := &str//声明指向int的指针
	fmt.Println(i, ptr, &i, str, &str)
	fmt.Println(*ptr)
	fmt.Printf("%t\n",ptr)
	fmt.Printf("%T\n",ptr)
	fmt.Printf("%T\n",*ptr)
}

在这里插入图片描述
创建指针的另一种方法——new()函数
new()函数可以创建一个对应类型的指针,创建过程会分配内存。被创建的指针指向的值为默认值。

	prtstring := new(string)
	*prtstring="laji"
	fmt.Printf("%T",prtstring)
	fmt.Printf(*prtstring)

在这里插入图片描述

2.容器

2.1 数组——固定大小的连续空间

声明数组
在这里插入图片描述
初始化数组
数组可以在声明时使用初始化列表进行元素设置

var array = [3]string{"hhhh", "oooo", "kkkk"}

也可以使用,“…”表示让编译器确定数组大小。

var array1 = [...]string{"111"}

数组遍历:

for k, v := range array{
		fmt.Println(k, v)
	}

Go的数组是值类型,数组间不会互相影响

fmt.Println(&array[0])
	test(array)


----------------------
func test(ints [3]string) {
	fmt.Println(&ints[0])
}

在这里插入图片描述
地址不同了

2.2 切片(slice)——动态分配大小的连续空间

在这里插入图片描述
切片是引用类型
切片默认指向一段连续内存区域,可以是数组,也可以是切片本身。
从连续内存区域生成切片是常见的操作,语法如下:
slice [开始位置:结束位置]

● slice表示目标切片对象。
● 开始位置对应目标切片对象的索引。
● 结束位置对应目标切片的结束索引。

从数组或切片生成新的切片拥有如下特性:
● 取出的元素数量为:结束位置-开始位置。
● 取出元素不包含结束位置对应的索引,切片最后一个元素使用slice[len(slice)]获取。
● 当缺省开始位置时,表示从连续区域开头到结束位置。
● 当缺省结束位置时,表示从开始位置到整个连续区域末尾。
● 两者同时缺省时,与切片本身等效。
● 两者同时为0时,等效于空切片,一般用于切片复位。
● 根据索引位置取切片slice元素值时,取值范围是(0~len(slice)-1),超界会报运行时错误。生成切片时,结束位置可以填写len(slice)但不会报错。

2.2.1 从指定范围中生成切片

切片和数组密不可分。
如果将数组理解为一栋办公楼,那么切片就是把不同的连续楼层出租给使用者。出租的过程需要选择开始楼层和结束楼层,这个过程就会生成切片。
含义就是:

	var slice = [3]int{1, 2, 3}
	ints := slice[0:2] // 1 2 
	ints[0]=2 // 修改 1 为2 
	fmt.Println(slice) //查看原数组是否被修改

在这里插入图片描述

2.2.2 表示原有的切片

slice[:] 表示得到和原数组大小一致的切片

2.2.3 重置切片,清空拥有的元素

slice[0:0] 切片大小变成空

i := slice[0:0]
	fmt.Println(i)

结果为:

[]

2.2.4 声明切片

每一种类型都可以拥有其切片类型,表示多个类型元素的连续集合。因此切片类型也可以被声明。

var name []int

2.2.5 使用make()函数构造切片

	var name []int
	name = make([]int, 3, 5)
	i2 := make([]int, 2, 8)
	fmt.Println(name,len(name),i2,len(i2))

在这里插入图片描述
i2均是预分配2个元素的切片,只是i2的内部存储空间已经分配了8个,但实际使用了2个元素。

2.2.6 使用append()函数为切片添加元素

Go语言的内建函数append()可以为切片动态添加元素。每个切片会指向一片内存空间,这片空间能容纳一定数量的元素。当空间不能容纳足够多的元素时,切片就会进行“扩容”。“扩容”操作往往发生在append()函数调用时。

	var name []int
	name= append(name, 1)
	fmt.Println(name,len(name),cap(name))
	name= append(name, 2)
	fmt.Println(name,len(name), cap(name))

在这里插入图片描述
切片在扩容时,容量的扩展规律按容量的2倍数扩充,例如1、2、4、8、16……

var nums []int
	for i:=0;i<10;i++{
		nums= append(nums, i)
		fmt.Printf("len:%d,cap:%d,pointer:%p\n",len(nums),cap(nums),nums)
	}

在这里插入图片描述

2.2.7 复制切片元素到另一个切片

使用Go语言内建的copy()函数,可以迅速地将一个切片的数据复制到另外一个切片空间中,copy()函数的使用格式如下

src := make([]int, 4, 8)
	fmt.Printf("len:%d,cap:%d,pointer:%p\n,srcvalue:%v\n", len(src), cap(src), src, src)
	dest := make([]int, 2, 10)
	fmt.Printf("len:%d,cap:%d,pointer:%p\n,destvalue:%v\n", len(dest), cap(dest), dest, dest)
	src[0] = 1
	fmt.Printf("len:%d,cap:%d,pointer:%p\n,destvalue:%v\n", len(dest), cap(dest), dest, dest)
	src[3] = 5
	copy(dest, src)
	fmt.Printf("len:%d,cap:%d,pointer:%p,destvalue:%v\n", len(dest), cap(dest), dest, dest)
	dest[0]=1213
	fmt.Printf("len:%d,cap:%d,pointer:%p,destvalue:%v\n", len(dest), cap(dest), dest, dest)
	fmt.Printf("len:%d,cap:%d,pointer:%p\n,srcvalue:%v\n", len(src), cap(src), src, src)

在这里插入图片描述

下面列举append的一些操作:

  1. 将切片 b 的元素追加到切片 a 之后:a = append(a, b…)

  2. 复制切片 a 的元素到新的切片 b 上:
    b = make([]T, len(a))
    copy(b, a)

  3. 删除位于索引 i 的元素:a = append(a[:i], a[i+1:]…)

  4. 切除切片 a 中从索引 i 至 j 位置的元素:a = append(a[:i], a[j:]…)

  5. 为切片 a 扩展 j 个元素长度:a = append(a, make([]T, j)…)

  6. 在索引 i 的位置插入元素 x:a = append(a[:i], append([]T{x}, a[i:]…)…)

  7. 在索引 i 的位置插入长度为 j 的新切片:a = append(a[:i], append(make([]T, j), a[i:]…)…)

  8. 在索引 i 的位置插入切片 b 的所有元素:a = append(a[:i], append(b, a[i:]…)…)

  9. 取出位于切片 a 最末尾的元素 x:x, a = a[len(a)-1], a[:len(a)-1]

  10. 将元素 x 追加到切片 a:a = append(a, x)

2.2.8 从切片中删除元素

Go语言并没有对删除切片元素提供专用的语法或者接口,需要使用切片本身的特性来删除元素。

	customer = append(customer[:index], customer[index+1:]...)

在这里插入图片描述
删除过程。

连续容器的元素删除无论是在任何语言中,都要将删除点前后的元素移动到新的位置。随着元素的增加,这个过程将会变得极为耗时。因此,当业务需要大量、频繁地从一个切片中删除元素时,如果对性能要求较高,就需要反思是否需要更换其他的容器(如双链表等能快速从删除点删除元素)。

3. 映射(map)

Go语言提供的映射关系容器为map。map使用散列表(hash)实现。

	mmap := make(map[string]int)
	mmap["okok"]=16
	fmt.Println(mmap["okok"])
	fmt.Println(mmap["ok2ok"])

在这里插入图片描述
填充式创建:
在这里插入图片描述

遍历map的“键值对”——访问每一个map中的关联关系

	for k, v := range mmap {
		fmt.Println(k, v)
	}
	for _, v := range mmap {
		fmt.Println( v)
	}
	for k:= range mmap {
		fmt.Println(k)
	}

在这里插入图片描述

使用delete()函数从map中删除键值对
在这里插入图片描述

清空map中的所有元素
Go语言中并没有为map提供任何清空所有元素的函数、方法。清空map的唯一办法就是重新make一个新的map。不用担心垃圾回收的效率,Go语言中的并行垃圾回收效率比写一个清空函数高效多了。

能够在并发环境中使用的map——sync.Map

sync.Map有以下特性:
● 无须初始化,直接声明即可。
● sync.Map不能使用map的方式进行取值和设置等操作,而是使用sync.Map的方法进行调用。Store表示存储,Load表示获取,Delete表示删除。
● 使用Range配合一个回调函数进行遍历操作,通过回调函数返回内部遍历出来的值。Range参数中的回调函数的返回值功能是:需要继续迭代遍历时,返回true;终止迭代遍历时,返回false。

4. 列表(list)

列表是一种非连续存储的容器,由多个节点组成,节点通过一些变量记录彼此之间的关系。列表有多种实现方法,如单链表、双链表等。

初始化列表
1.通过container/list包的New方法初始化list

l := list.New()

2.通过声明初始化list

	l2 := list.List{}

双链表支持从队列前方或后方插入元素,分别对应的方法是Push Front和Push Back。
举例:

	l := list.New()
	l.PushBack("fiest")          //增加尾部
	front := l.PushFront("dddd") // 增加头部
	l.InsertAfter("aaaa", front)
	l.Remove(front)

在这里插入图片描述

遍历列表——访问列表的每一个元素
在这里插入图片描述

  • 1
    点赞
  • 2
    收藏
  • 打赏
    打赏
  • 0
    评论

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:像素格子 设计师:CSDN官方博客 返回首页
评论

打赏作者

everyD_struggle

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值