go的数组，切片，map

数组

//数组：数组是同一类元素的集合

package main

import "fmt"

func main() {
	//1 基本使用：定义
	//定义了一个大小为3的int类型数组
	//数组在定义阶段 大小和类型就已经确定了
	//var a [3] int //之定义，没有初始化
	//fmt.Println(a)

	//2 使用数组(从0开始)
	//var a [3] int
	//a[2]=100
	//fmt.Println(a)


	//3 定义并赋初值(同样是三种方式)
	//var a [3] int = [3] int {1,2,3}
	//var a = [3] int {1,2,3}
	//a := [3] int {1,2,3}

	//只给第二个位置设置为99
	//a := [3] int {2:99}
	//进阶版
	//a := [3] int {2:99,1:88}
	//fmt.Println(a)


	//4 数组的大小是类型的一部分
	//比如下面的两个不是一个类型
	//var a [2] int
	//var b [3] int

	//5 数组是值类型（当参数传递到函数中，修改并不会改变原来的值）
	//go语言中都是copy传递
	/*
	python 中都是引用传递，一切皆对象，当做参数传递，就是把地址传递过去了
	python 中比较特殊：可变类型，不可变类型
	 */

	//var a [3] int =[3]int{5,6,7}
	//fmt.Println(a)
	//test(a)
	//fmt.Println(a)  //数组是值类型，并不会修改

	//6 数组长度
	//var a [3] int =[3]int{5,6,7}
	//fmt.Println(len(a))

	//7 循环数组
	//方式一
	//var a [3] int =[3]int{5,6,7}
	//for i:=0;i<len(a);i++{
	//	fmt.Println(a[i])
	//}

	//方式二
	//在go语言中range是一个关键字
	//var a [3] int =[3]int{5,6,7}
	//for i,v:=range a{
	//	fmt.Println(i) //索引
	//	fmt.Println(v) //数组的值
	//}

	//函数如果返回两个值，必须用两个值来接收
	//range可以用一个值类接收

	//只取索引
	//for i:=range a{
	//	fmt.Println(i) //索引
	//}

	//只取值
	//for _,v:=range a{
	//	fmt.Println(v) //值
	//}


	//8 多维数组
	// 定义一个二维数组
	//var a [3][2]int
	//a[1][0] = 999

	//定义并初始化
	var a [3][2]int = [3][2]int{{1,2},{3,4},{5,6}}
	fmt.Println(a)


	//补充：类型的默认值
	//var a int
	//var b float32
	//var c string
	//var d bool
	//fmt.Println(a)  //0
	//fmt.Println(b)  //0
	//fmt.Println(c)  //空""
	//fmt.Println(d)  //false

}

func test(a [3] int){
	a[0]=999
	fmt.Println(a)
}

切片

//切片是由数组建立的一种方案，切片本省不拥有任何数据，只是对现有数组的引用
//切片底层依附于数组
package main

import "fmt"

func main() {
	//1创建切片（基于一个数组创建）
	//var a [9] int = [9] int {1,2,3,4,5,6,7,8,9}
	//2 基于数组 切出一部分成为切片
	// []int 中括号中没有东西就是切片
	//var b [] int
	// 没有-1 没有步长
	//b=a[0:3] //切片是一个前闭后开的区间
	//b=[:]
	//fmt.Println(b)

	//3 使用切片
	//fmt.Println(b[0])

	//4 切片的修改会影响 底层数组，数组的修改也就影响切片
	//var a [9] int = [9] int {1,2,3,4,5,6,7,8,9}
	//var b []int=a[0:3]
	//fmt.Println(a)
	//fmt.Println(b)
	//a[0]=999
	//fmt.Println(a)
	//fmt.Println(b)


	//5 切片的长度和容量
	//var a [9] int = [9] int {1,2,3,4,5,6,7,8,9}
	//var b []int=a[0:3]
	//
	//fmt.Println(len(b))  //长度
	////切片的容量是9 意思是 可以往里面追加值，追加成9个
	//fmt.Println(cap(b))  //容量

	//6 追加值
	//var a [9] int = [9] int {1,2,3,4,5,6,7,8,9}
	//var b []int=a[2:3]
	//b=append(b,1)
	//b=append(b,11,22,33,44,55)
	//fmt.Println(len(b))
	//fmt.Println(cap(b))
	//fmt.Println(b)
	//fmt.Println(a)
	//到了数组的尾部继续追加值，会怎样
	//b=append(b,999)
	//fmt.Println(len(b))
	// 总结1：当切片追加值，超过了切片容量会基于当前切片容量的最大值 然后翻倍
	//fmt.Println(cap(b))

	// 总结2：一旦超过了原数组，就会重新申请数组，把数据copy到新数组，切片和原数组就没多大关系了
	//fmt.Println(a)
	//fmt.Println(b)
	//a[8]=777
	//fmt.Println(a)
	//fmt.Println(b)

	//7 通过make创建切片（底层依附于数组）
	//var a [] int
	//// 切片零值是什么？nil类型：是所有引用类型的空值
	//fmt.Println(a)
	//if a==nil{
	//	fmt.Println("我是空的")
	//}

	//3是长度 4是容量
	//var a [] int=make([]int,3,4)
	//3是长度 3是容量
	//var a [] int=make([]int,3)
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))
	//
	//a=append(a,555)
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))

	//8 切片定义并赋初值
	//var a [] int = [] int{1,2,3}
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))

	//9 切片是引用类型，当参数传递 会修改原来的值
	//var a [] int = [] int{1,2,3}
	//fmt.Println(a)
	//test1(a)
	//fmt.Println(a)


	//10 多维切片
	//这只是初始化了第一层
	//var a [][]int=make([][]int,2,3)
	//fmt.Println(a)
	////会报错
	////a[0][0]=999
	//
	////如何做？
	////第二层初始化
	//a[0]=make([] int,2,3)
	//a[0][1]=999
	//fmt.Println(a)

	//一般定义并赋初值这个用的多
	//var a [][]int=[][]int{{1,2,3},{4,5,6},{7,8,9}}
	//fmt.Println(a)

	//11 切片的copy
	//var a []int = make([]int,3,4)
	//var b []int = make([]int,4,6)
	//a[0]=11
	//a[1]=22
	//a[2]=33
	//fmt.Println(a)
	//fmt.Println(b)
	//
	//copy(b,a)
	//fmt.Println(b)

	//12 切片越界
	//var a []int = make([]int,3,4)
	//a[0]=11
	//a[1]=22
	//a[2]=33
	//
	//fmt.Println(a[3])
	
	//13 切片循环
	//var a []int = make([]int,3,4)
	//for i:=0;i<len(a);i++ {
	//	fmt.Println(a[i])
	//}

	var a []int = make([]int,3,4)
	for i,v:=range a{
		fmt.Println(i)
		fmt.Println(v)
	}
}

func test1(a []int)  {
	a[0]=999
	fmt.Println(a)
}

map

/*
map:hash 字典 key,value存储
 */

package main

import "fmt"

func main() {
	//1 map 的定义和使用
	//map[key类型]value类型  key的类型必须可hash，数字，字符串
	//map的零值：nil 他是一个引用类型
	//var a map[int]string
	//fmt.Print(a)
	//if a==nil{
	//	fmt.Println("我是空的")
	//}


	// 2 定义了 没有初始化 使用
	//var a map[int]string
	//没有初始化报错
	//a[1]="alen"
	//初始化用make
	//var a map[int]string= make(map[int]string)
	//a[1]="alen"
	//fmt.Println(a)

	// 3 获取元素
	//var a map[int]string= make(map[int]string)
	//fmt.Println(a[0]) //取出value值的空值

	//4 统一的方案判断value值是否存在

	//a[0]可以返回两个值 一个是value值，另一个是true和false
	//var a map[int]string= make(map[int]string)
	//v,ok :=a[0]
	//fmt.Println(v)
	//fmt.Println(ok)

	//5 map 删除元素
	//var a map [int]int=make(map[int]int)
	//a[1]=11
	//a[2]=22
	//fmt.Println(a)
	////根据key删
	//delete(a,1)
	//fmt.Println(a)

	//6 map 长度
	//var a map [int]int=make(map[int]int)
	//a[1]=11
	//a[2]=22
	//fmt.Println(len(a))

	//7 map是引用类型
	//var a map [int]int=make(map[int]int)
	//a[1]=11
	//test2(a)
	//fmt.Println(a)

	//8 map相等性
	//var a map [string]string=make(map[string]string)
	//a["name"]="alen"
	//var b map [string]string=make(map[string]string)
	//b["name"]="alen"

	//不能这样判断，map只能nil比较
	//if a==nil {
	//
	//}


	//9 循环map
	var a map[string]string=map[string]string{"name":"lqz","age":"19","sex":"男"}
	//搞不了
	//for i:=0;i<len(a) ; i++ {
	//	fmt.Println(a[i])
	//
	//}

	//range循环
	for k,v:=range a{
		fmt.Println(k)
		fmt.Println(v)
	}

	// 10 map是无序的（python中字典从3.6以后有序了，3.6之前无序，底层如何实现的，看博客）



}

func test4(a map[int]int)  {
	a[1]=999
	fmt.Println(a)
}


}
func test2(map [int]int){
	a[1]=999
	fmt.Println(a)
}