Go语言基础第05天（切片和map）

兰公子&

已于 2022-10-18 20:01:11 修改

阅读量135

点赞数

分类专栏： go架构师文章标签： golang 运维开发学习

于 2022-10-18 17:09:34 首次发布

本文链接：https://blog.csdn.net/qq_51685718/article/details/127371742

版权

go架构师专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1.统计字母

func main0101() {
	//sdjfjsdfuiyeudhajsh
	var arr [20]byte
	for i := 0; i < len(arr); i++ {
		fmt.Scanf("%c", &arr[i])
	}
	// ch[26]  ch[0]-ch[25]
	var ch [26]int //用来统计字符个数

	//记录字母出现的次数
	for i := 0; i < len(arr); i++ {
		ch[arr[i]-'a']++
	}
	//打印字母出现次数
	for i := 0; i < len(ch); i++ {
		if ch[i] > 0 {
			fmt.Printf("字母：%c出现：%d次\n", 'a'+i, ch[i])
		}
	}

2.双色球

// 随机一注双色球彩票信息 红球6个 1-33 不能重复
func main0102() {
	//获取随机数种子
	rand.Seed(time.Now().UnixNano())

	var redball [6]int

	for i := 0; i < len(redball); i++ {
		//遍历之前存在的值和新随机数是否有重复
		//redball[i] = rand.Intn(33)+1//0-32
		temp := rand.Intn(33) + 1
		for j := 0; j < i; j++ {
			if temp == redball[j] {
				temp = rand.Intn(33) + 1
				j = -1
				continue
			}
		}

		redball[i] = temp
	}

	fmt.Println(redball, "+", rand.Intn(16)+1)

}

3.二维数组

// 随机一注双色球彩票信息 红球6个 1-33 不能重复
func main0102() {
	//获取随机数种子
	rand.Seed(time.Now().UnixNano())

	var redball [6]int

	for i := 0; i < len(redball); i++ {
		//遍历之前存在的值和新随机数是否有重复
		//redball[i] = rand.Intn(33)+1//0-32
		temp := rand.Intn(33) + 1
		for j := 0; j < i; j++ {
			if temp == redball[j] {
				temp = rand.Intn(33) + 1
				j = -1
				continue
			}
		}

		redball[i] = temp
	}

	fmt.Println(redball, "+", rand.Intn(16)+1)

}

func main0202() {
	var arr [3][4]int
	//len(二维数组名) 二维数组的行数
	fmt.Println(len(arr))
	//arr[0]表示二维数组的第一行
	//len(二维数组名[下标])  二维数组列数
	fmt.Println(len(arr[0]))

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

	}

}

4.切片

func main0301() {
	//数组定义 var  数组名 [元素个数]数据类型

	//切片定义 var 切片名 []数据类型

	//var s [] int
	//fmt.Println(s)
	//自动推导类型创建切片  make([]数据类型,5)
	s := make([]int, 5)
	//通过下标为切片赋值
	s[0] = 123
	s[1] = 234
	s[2] = 345
	s[3] = 456
	s[4] = 567
	//s[6]=678//err
	//通过append 添加切片信息
	s = append(s, 678, 789, 8910)

	fmt.Println(s)

	//通过len查看切片长度

	fmt.Println(len(s))
}

func main0302() {
	s := make([]int, 5)

	s[0] = 123
	s[1] = 234
	s[2] = 345
	s[3] = 456
	s[4] = 567

	//遍历

	//for i := 0; i<len(s);i++  {
	//	fmt.Println(s[i])
	//}

	for i, v := range s {
		fmt.Println(i, v)
	}
	fmt.Println(s)
}

func main0303() {
	//不写元素个数叫切片 必须写元素个数的叫数组
	var s []int = []int{1, 2, 3, 4, 5}

	s = append(s, 6, 7, 8, 9)

	//容量大于等于长度
	//fmt.Println(s)
	fmt.Println("长度：", len(s))
	fmt.Println("容量：", cap(s))

	//容量每次扩展为上次的倍数
	s = append(s, 6, 7, 8, 9)

	//fmt.Println(s)
	fmt.Println("长度：", len(s))
	fmt.Println("容量：", cap(s))

	s = append(s, 6, 7, 8, 9)

	fmt.Println("长度：", len(s))
	fmt.Println("容量：", cap(s))

	//如果整体数据没有超过1024字节 每次扩展为上一次的倍数  超过1024 每次扩展上一次的1/4
	s = append(s, 6, 7, 8, 9)

	fmt.Println("长度：", len(s))
	fmt.Println("容量：", cap(s))
}

func main0304() {
	s := make([]int, 5)
	s[0] = 1
	//使用append在长度后添加数据
	s = append(s, 1, 2, 3)
	//
	//fmt.Println(s)
	//fmt.Println(cap(s))
	//在切片打印时 只能打印有效长度中的数据 cap不能作为数组打印的条件
	for i := 0; i < len(s); i++ {
		fmt.Println(s[i])
	}
}

5.切片截取

func main0401() {
	s := []int{1, 2, 3, 4, 5}
	//切片名[起始下标:]
	//slice:=s[2:]
	//切片名[:结束位置] 不包含结束位置
	//slice:=s[:2]
	//切片名[起始位置:结束位置]
	//slice:=s[2:5]
	//切片名[起始位置:结束位置:容量]
	slice := s[0:2:2] //大于等于len  小于等于cap  len <= xxx <= cap
	fmt.Println(cap(slice))
	fmt.Println(slice)
}

func main0402() {
	s := []int{1, 2, 3, 4, 5}
	//slice:=s[2:4]//[1 2]
	//
	//slice[1]=123
	//
	//fmt.Println(slice)
	//
	//fmt.Println(s)
	//
	切片名  本身就是地址
	一个字节在内存中占8bit（位）
	//fmt.Printf("%p\n",s)
	//fmt.Printf("%p\n",&s[1])
	//fmt.Printf("%p\n",&s[2])
	//fmt.Printf("%p\n",slice)
	//切片名[:]获取切片中所有元素
	slice := s[:]
	fmt.Println(slice)

	news := make([]int, 5)
	copy(news, s)
	fmt.Printf("%p\n", news)
	fmt.Printf("%p\n", s)

}

copy(x,y)把y切片中内容copy到x切片中

6.切片追加与拷贝

func main0501() {

	var s []int
	//s[0]=123
	//在使用append添加数据是 切片的地址可能或发生变量 如果容量扩充导致输出存储溢出 切片会自动找寻新的空间存储数据
	//同时也会将之前的数据进行释放
	//使用append添加数据
	s = append(s, 1, 2, 3, 4, 5)

	fmt.Println(len(s)) //0
	fmt.Println(cap(s)) //0
	fmt.Printf("%p\n", s)

	s = append(s, 1, 2, 3, 4, 5)

	fmt.Println(len(s)) //0
	fmt.Println(cap(s)) //0
	fmt.Printf("%p\n", s)
}

func main0502() {
	s1 := []int{1, 2, 3, 4, 5}
	//var s2 []int//0//0
	s2 := make([]int, 5)
	//将s1切片中的数据拷贝到s2中 s2中要有足够的容量
	//使用拷贝操作后s1 s2是两个独立空间 不会相互影响
	copy(s2, s1)

	//s2[2]=123
	fmt.Println(s2)

	fmt.Println(s1)

	fmt.Printf("%p\n", s1)
	fmt.Printf("%p\n", s2)
}

func main0503() {
	s1 := []int{1, 2, 3, 4, 5}
	s2 := make([]int, 2, 6)
	//如果想拷贝具体的切片中的片段 需要使用切片中的截取
	copy(s2, s1[1:])
	fmt.Println(s2)
}

7.切片作为函数参数

func test(s []int) {
	//fmt.Printf("%p\n",s)
	s[2] = 123
}
func main0601() {
	s := []int{1, 2, 3, 4, 5}
	test(s)
	//fmt.Printf("%p\n",s)
	fmt.Println(s)
}

func BubbleSort(s []int) {

	for i := 0; i < len(s)-1; i++ {
		for j := 0; j < len(s)-1-i; j++ {
			if s[j] > s[j+1] {
				s[j], s[j+1] = s[j+1], s[j]
			}
		}
	}
}

func main0602() {

	s := []int{9, 1, 5, 6, 7, 3, 10, 2, 4, 8}
	//切片作为函数参数是地址传递 形参可以改变实参的值
	//在实际开发者 建议使用切片代替数组
	BubbleSort(s)

	fmt.Println(s)
}

func test1(s []int) []int {
	//如果使用append操作切片可能改变切片的地址 需要使用返回值给实参赋值
	s = append(s, 4, 5, 6)
	fmt.Printf("%p\n", s)

	fmt.Println(s)
	return s
}

func main0603() {
	s := []int{1, 2, 3}
	fmt.Printf("%p\n", s)
	s = test1(s)
	fmt.Println(s)
	fmt.Printf("%p\n", s)
}

8.猜数字

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main0701() {
	//创建随机数种子
	rand.Seed(time.Now().UnixNano())
	//生成100-999随机数
	//randNum:=rand.Intn(900)+100
	//random:=make([]int,3)
	//random[0]=randNum/100
	//random[1]=randNum/10%10
	//random[2]=randNum%10
	random := make([]int, 3)
	random[0] = rand.Intn(9) + 1 //1-9
	random[1] = rand.Intn(10)
	random[2] = rand.Intn(10)

	usernum := make([]int, 3)

	var num int
	var flag int = 0
	for {
		for {
			fmt.Println("请输入一个三位数")
			fmt.Scan(&num)
			if num >= 100 && num <= 999 {
				break
			}
			fmt.Println("输入错误，请重新输入")
		}
		usernum[0] = num / 100
		usernum[1] = num / 10 % 10
		usernum[2] = num % 10

		for i := 0; i < 3; i++ {

			if usernum[i] > random[i] {
				fmt.Printf("您输入的第%d位数太大了\n", i+1)
			} else if usernum[i] < random[i] {
				fmt.Printf("您输入的第%d位数太小了\n", i+1)
			} else {
				fmt.Printf("恭喜你，第%d位数相同\n", i+1)
				flag++
			}

		}
		if flag == 3 {
			fmt.Println("成功")
			break
		} else {
			flag = 0
		}
	}

}

9.map定义和使用

func main0801() {
	//map[keyType]valueTye

	//var m map[int]string
	m := make(map[int]string, 1)
	//map[key] key 是一个基本数据类型
	//map的长度是自动扩容的
	//map中的数据是无序存储的
	m[100] = "张三"
	m[2] = "李四"
	m[5] = "王五"
	//for i,v  index  v  value
	for k, v := range m {
		fmt.Println(k, v)
	}
	//fmt.Println(m)
}

func main0802() {
	m := make(map[string]int, 1)

	//重新赋值
	m["尼古拉斯赵四"] = 10
	//可以通过验证key对应的value是否有值  根据条件作出相应操作
	_, ok := m["尼古拉斯赵四"]
	if ok {
		fmt.Println("该key以存在")
	} else {
		m["尼古拉斯赵四"] = 20
	}
	//map中key和value不能翻过来操作
	//m[10]="布莱恩特王老七"//err
	//map在定义时 key是唯一的  不允许重复
	//m:=map[string]int{"尼古拉斯赵四":10,"迈克尔刘能":20}

	fmt.Println(m)
}

10.map中的值

func main0901() {

	//m:=make(map[byte]int)
	m := make(map[int]string, 1)
	//在map中值允许重复
	m[0] = "刘备"
	m[1] = "张飞"
	m[2] = "张飞"

	//fmt.Println(m[2])
	//在map打印中如果出现没有定义的map 默认值为空
	//fmt.Println("---",m[3],"---")

	//v,ok:=m[3]
	//if ok {
	//	fmt.Println(v)
	//}else {
	//	fmt.Println("可以不存在")
	//}

	for k, v := range m {
		//v,ok:=m[k]
		fmt.Println(k, v)
	}
}

11.删除map中元素

func main1001() {
	m := map[int]string{101: "刘备", 105: "关羽", 106: "李逵"}

	//fmt.Printf("%T",m)
	//delete(map,key)
	delete(m, 101)
	//delete在删除map中的元素的时候 如果可以 不存在 不会报错
	//delete(m,104)
	//delete(m,107)

	fmt.Println(m)
}

12.map做函数参数

func demo(m map[int]string) {
	//map在函数中添加数据 可以的  影响主调函数中实参的在
	m[102] = "杨二郎"
	m[103] = "唐老二"
	fmt.Println(len(m))

	delete(m, 101)
	fmt.Println(len(m))
}
func main1101() {
	m := make(map[int]string, 1)
	m[101] = "孙悟空"
	fmt.Println(len(m))
	//fmt.Println(cap(m))//err
	//map作为函数参数是地址传递 （引用传递）
	demo(m)

	fmt.Println(m)
}