Go基础数组切片 Map

数组

数组介绍

数组可以存放多个同一类型数据数组也是一种数据类型在Go 中数组是指类型

案例

package main

import "fmt"

func main() {
	// 计算 6个人 平均体重 以及体重总和
	var person [6]float64
	person[0] = 98
	person[1] = 90
	person[2] = 91
	person[3] = 3
	person[4] = 4
	person[5] = 96
	// 计算平均体重
	sum := 0.0
	for i := range person {
		sum += person[i]
	}
	sprintf := fmt.Sprintf("%.2f", sum/float64(len(person)))
	fmt.Printf("avg=%v", sprintf)
}

数组的使用

访问数组元素

数组名【下标】比如你要使用a 数组的第三个的第三个元素 a[2]

入门案例

package main

import "fmt"

func main() {
	//终端循环输入 5个成绩 保存到 float 64 数组
	var scorearr [5]float64
	for i := 0; i < len(scorearr); i++ {
		fmt.Printf("请输入第%d个学生成绩", i+1)
		fmt.Scanln(&scorearr[i])

	}
	for i := 0; i < len(scorearr); i++ {
		fmt.Print(scorearr[i])
	}
}

初始化数组的方式

package main

func main() {
	// 数组初始化的方式
	var numArr01 [3]int = [3]int{1, 2, 3}
	println(numArr01)

	var numArr02 = [3]int{1, 6, 3}
	println(numArr02)

	var numArr03 = [...]int{1, 6, 3}
	println(numArr03)

	var numArr04 = [...]int{1: 800, 0: 99, 2: 44}
	println(numArr04)
}

遍历数组的方式

package main

import "fmt"

func main() {
	// 数组初始化的方式
	names := [...]string{"娇娇", "Amy", "小张"}
	// for range 遍历
	for i, name := range names {
		// 第一个返回值 index 是数组的下标
		// 第二个 value 是在 该下标位置的值
		// 他们都是在 for 内部的局部变量
		// 遍历数组元素的时候 不想要 index 可以用下划线代替
		fmt.Printf("i=%v  name=%v \n", i, name)
	}

}

数组使用的时候注意细节

1,数组是多个相同类型数据的组合一个数组一旦声明、定义长度是固定的不能动态变化了
2，var arr[] int 这时就是一个 slice 切片
3，数组中的元素类型值类型和引用类型不能一块使用
4)数组创建后，如果没有赋值,有默认值(零值)数值类型数组:默认值为0字符串数组:默认值为""bool数组:默认值为false
5)使用数组的步骤1.声明数组并开辟空间给数组各个元素赋值3使用数组6)数组的下标是从o开始的。
7)数组下标必须在指定范围内使用，否则报panic:数组越界，比如var arr [5]int则有效下标为0-4
8)Go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响

切片

切片的基本介绍

1)切片的英文是slice
2)切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的l机制。
3)切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样。
4)切片的长度是可以变化的，因此切片是一个可以动态变化数组。
5)切片定义的基本语法:
var变量名[类型
比如: var a [] int

package main

import "fmt"

func main() {
	// 切片的基本使用
	var intArr [5]int = [...]int{1, 2, 4, 5, 6}
	// 声明、定义 一个切片
	//intArr[1:3] 表示的是 引用数组intArr
	// 引用 数组的起始下标为1 最后的下标为 3 （不包括3）
	slice := intArr[1:3]
	fmt.Println(slice)
	fmt.Println(len(slice))
	fmt.Println(cap(slice))

}

切片的三种方式

方式一

定义一个切片，然后让切片去引用一个已经创建好的数据

package main

import "fmt"

func main() {
	// 切片的基本使用
	var intArr [5]int = [...]int{1, 2, 4, 5, 6}
	// 声明、定义 一个切片
	//intArr[1:3] 表示的是 引用数组intArr
	// 引用 数组的起始下标为1 最后的下标为 3 （不包括3）
	slice := intArr[1:3]
	fmt.Println(slice)
	fmt.Println(len(slice))
	fmt.Println(cap(slice))

}

方式二

通过make 来创建切片

package main

import "fmt"

func main() {
	// 切片的基本使用
	//var intArr [5]int = [...]int{1, 2, 4, 5, 6}
	// 声明、定义 一个切片 参数说明: type:就是数据类型len:大小cap :指定切片容量，
	ints := make([]int, 3, 9)
	ints[0] = 80
	ints[1] = 80
	ints[2] = 80
	fmt.Println(ints)
}

方式三

定义一个切片直接就指定具体数据使用原理类似于make的方式

package main

func main() {
	var slice []int = []int{1, 3, 5}
	println(slice)
}

切片注意事项和细节说明

切片初始化时var slice = arr[startlndex:endIndex]
说明:从arr数组下标为startlndex，取到下标为endIndex的元素(不含arr[endIndex])。
切片初始化时，仍然不能越界。范围在[O-len(arr)]之间，但是可以动态增长
.1) var slice = arr[0:end]可以简写var slice = arr[:end]
2) var slice = arr[start:lep(arr)]可以简写: var slice = arr[start:]
3) var slice = arr[O:len(arr)]可以简写: var slice = arr[:]
cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用
切片可以继续切片

Map

map的声明
基本语法
var map变量名map[keytype]valuetypekey可以是什么类型
golang中的map，的 key可以是很多种类型，比如 bool,数字，string,指针,channel ,还可以是只包含前面几个类型的接口,结构体，数组
通常为int .string
注意: slice，map还有function不可以，因为这几个没法用==来判断

package main

import "fmt"

func main() {
	// 方式一 声明一个map
	var mapdemo map[int]string
	mapdemo = make(map[int]string, 10)
	mapdemo[1] = "娇娇"
	mapdemo[2] = "小张"
	fmt.Println(mapdemo)
	// 方式二
	m := make(map[int]string)
	m[1] = "娇娇"
	m[2] = "小张"
	// 方式三
	m1 := map[int]string{
		1: "ee",
		2: "ee",
	}
	fmt.Println(m1)
}

案例

用map 存放学生学号姓名和年龄

package main

import "fmt"

func main() {
	m := make(map[int]map[string]int)
	m[1] = map[string]int{
		"娇娇":   18,
		"amy":  18,
		"kiko": 18,
	}
	for i, m2 := range m {
		fmt.Printf("学生的学号为:%v \n ", i)
		for s, i2 := range m2 {
			fmt.Printf("学生的姓名为:%v \n ", s)
			fmt.Printf("学生的年龄为:%v \n ", i2)
		}

	}
}

map的切片

基本介绍

切片的数据类型如果是map，则我们称为slice of map，map切片，这样使用则map个数就可以动态变化了。

// 要求:使用一个map来记录monster的信息name和 age，也就是说一个monster对应一个map.并且妖怪的个数可以动态的增加=>map切片
func Monster() []map[string]string {
	// 创建一个 空的map
	m := make([]map[string]string, 2)
	m[0] = make(map[string]string)
	m[0]["name"] = "悟空"
	m[0]["age"] = "19"

	m[1] = make(map[string]string)
	m[1]["name"] = "悟空1"
	m[1]["age"] = "191"
	// 此时想童泰添加 必须append

	m2 := make(map[string]string)
	m2["name"] = "dddd"
	m2["age"] = "22"

	m = append(m, m2)

	return m
}

	
func main() {
	monster := Monster()
	for _, m := range monster {
		fmt.Println(m)

	}
	}