Go语言基础学习(数组、切片、Map)

1. 数组

数组声明

var 数组变量名 [元素数量]T

// 定义一个长度为3元素类型为int的数组a
var a [3]int

数组初始化

var a = [3]int{1,2,3}
var numArray = [...]int{1, 2, 3}
var arr = [...]int{1,2,3}
fmt.Println(arr)
fmt.Printf("%T",arr)	//[3]int

指定索引值的方式来初始化数组

a := [...]int{1: 1, 3: 5}
fmt.Println(a)  // [0 1 0 5]

数组遍历

var arr = [...]int{1,2,3}
for i := 0; i < len(arr); i++ {
	fmt.Println(arr[i])
}

var arr = [...]int{1,2,3}
for index,value := range arr{
	fmt.Println(index,value)
}

多维数组

多维数组只有第一层可以使用…来让编译器推导数组长度。

var a = [2][3]int{{1,2,3},{4,5,6}}
var arr = [...][3]int{{1,2,3},{4,5,6},{7,8,9}}
fmt.Println(arr)
fmt.Println(a)

for _, v1 := range a{
	for _, v2 := range v1{
		fmt.Println(v2)
	}
}

注意

数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。
数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
[n] * T表示指针数组，* [n]T表示数组指针 。

2. 切片

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

声明

var name []T

var s []int
var ss = []int{}
var sss = []int{1,2,3,4,5,6}
fmt.Println(s)
fmt.Println(ss)
fmt.Println(sss)

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

fmt.Println(cap(s))
fmt.Println(len(sss))

fmt.Println(s == nil) //切片是引用类型，不支持直接比较，只能和nil比较

切片表达式

切片表达式从字符串、数组、指向数组或切片的指针构造子字符串或切片。

由数组得切片

var sss = [6]int{1,2,3,4,5,6}
ss := sss[3:5]
fmt.Println(ss)	//[4 5]

可以省略切片表达式中的任何索引

a[2:]  // 等同于 a[2:len(a)]
a[:3]  // 等同于 a[0:3]
a[:]   // 等同于 a[0:len(a)]

切片再执行切片表达式时（切片再切片），high的上限边界是切片的容量cap(a)，而不是长度len(a)

完整的切片表达式

a[low : high : max]
在完整切片表达式中只有第一个索引值（low）可以省略；它默认为0
切片容量会设置为max-low
判断切片是否为空，使用len(s) == 0来判断，而不应该使用s == nil来判断。
完整切片表达式需要满足的条件是0 <= low <= high <= max <= cap(a)

make()函数构造切片

make([]T, size, cap)

a := make([]int,2,10)
fmt.Println(a)

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil。

赋值拷贝

切片是引用类型，拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容

a := make([]int,2,10)
a[0] = 1
a[1] = 2
b := a
b[0] = 100
fmt.Println(a)
fmt.Println(b)

切片的遍历

同数组遍历

append()方法为切片添加元素

通常都需要用原变量接收append函数的返回值。
可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素（后面加…）

var s []int
s = append(s, 1)        // [1]
s = append(s, 2, 3, 4)  // [1 2 3 4]
s2 := []int{5, 6, 7}  
s = append(s, s2...)    // [1 2 3 4 5 6 7]

通过var声明的零值切片可以在append()函数直接使用，无需初始化。

var s []int
s = append(s, 1, 2, 3)

copy()函数复制切片

切片是引用类型，直接赋值会指向同一块内存地址

copy(destSlice, srcSlice []T)

// copy()复制切片
a := []int{1, 2, 3, 4, 5}
c := make([]int, 5, 5)
copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
fmt.Println(a) //[1 2 3 4 5]
fmt.Println(c) //[1 2 3 4 5]
c[0] = 1000
fmt.Println(a) //[1 2 3 4 5]
fmt.Println(c) //[1000 2 3 4 5]

从切片中删除元素

从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]…)

3. 取地址与取值

&取地址
*取值

n := 18
p := &n
fmt.Println(p)	//0xc00000e0c0
fmt.Printf("%T\n",p)	//*int
fmt.Println(*p)	//18
fmt.Printf("%T\n",*p)	//int

new函数申请内存地址

func new(Type) * Type

var a1 *int
fmt.Println(a1)	//
//fmt.Println(*a1)	//报错
var a2 = new(int)
fmt.Println(a2)	//0xc00000e0c0
fmt.Println(*a2)	//0

make申请内存地址

make也是用于内存分配的，区别于new，它只用于slice、map以及channel的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。

func make(t Type, size …IntegerType) Type

var b map[string]int
b = make(map[string]int, 10)

4. Map

内部使用散列表（hash）实现。

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。

map[KeyType]ValueType

map类型的变量默认初始值为nil，需要使用make()函数来分配内存。
make(map[KeyType]ValueType, [cap])

var m map[string]int
m = make(map[string]int,10)
m["张三"] = 25
m["李四"] = 20
fmt.Println(m)	//map[张三:25 李四:20]
fmt.Println(m["张三"])	//25

userInfo := map[string]string{
		"username": "张三",
		"password": "123456",
	}

判断键是否存在

value, ok := map[key]

value,ok := m["李四"]
fmt.Println(value,ok)	//20 true

遍历

遍历map时的元素顺序与添加键值对的顺序无关。

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

for k := range m{
	fmt.Println(k)
}

delete函数删除键值对

delete(map, key)

指定顺序遍历map

func main() {
	rand.Seed(time.Now().UnixNano()) //初始化随机数种子

	var scoreMap = make(map[string]int, 200)

	for i := 0; i < 100; i++ {
		key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
		value := rand.Intn(100)          //生成0~99的随机整数
		scoreMap[key] = value
	}
	//取出map中的所有key存入切片keys
	var keys = make([]string, 0, 200)
	for key := range scoreMap {
		keys = append(keys, key)
	}
	//对切片进行排序
	sort.Strings(keys)
	//按照排序后的key遍历map
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}
}

元素为map类型的切片

var mapSlice = make([]map[string]string, 3)
mapSlice[0] = make(map[string]string,10)
mapSlice[0]["张三"] = "男"
fmt.Println(mapSlice)	//[map[张三:男] map[] map[]]

值为切片类型的map

var sliceMap = make(map[string][]string, 3)
sliceMap["张三"] = []string{"男","25岁"}
fmt.Println(sliceMap)	//map[张三:[男 25岁]]