06 Matrizes, fatias e mapas

Variedade

O array pode armazenar vários dados do mesmo tipo.
Definição do array: var Nome do array [tamanho do array] Tipo de dados
Acesso aos elementos do array: nome do array [subscrito], subscrito começa em 0
O endereço do array pode ser obtido por nome do array e array O nome de
cada intervalo de endereço de elemento da matriz é determinado de acordo com o tipo de dados na matriz, como: int64 -> 8 int32-> 4
Notas

1. Uma vez declarado, o comprimento da matriz é fixo e não pode ser alterado dinamicamente
2. Quando var arr [] int é definido assim, ele realmente define uma fatia
3. Os elementos da matriz podem ser de qualquer tipo de dados, mas não podem ser misturados
4. Depois que a matriz é criada, se nenhum valor for atribuído, o valor padrão do tipo de dados é armazenado por padrão
5. Quando um array é usado como parâmetro, ele é passado por valor (atribuindo um novo valor). Se você deseja modificar o array em outros métodos, você precisa operá-lo por meio de ponteiros.
   6. O comprimento do array faz parte de a matriz. As matrizes com comprimentos inconsistentes não podem ser passadas para a função.

Código de amostra

func test07(){
    
    
	//数组的声明及使用
	var arr01 [3] int
	arr01[0] = 1
	arr01[1] = 2
	//数组的声明及使用
	arr02 :=[3]int{
    
    1,2,3}
	fmt.Println(arr01,arr02)

	var arr03 = [...]int{
    
    8,9,11,1}
	var arr04 = [...]int{
    
    1:8,2:9,3:11,0:1}
	fmt.Println(arr03,arr04)
	//数组遍历
	for i:=0;i<len(arr01);i++{
    
    
		fmt.Println(i,arr01[i])
	}
	//数组遍历2
	for index,value :=range arr01{
    
    
		fmt.Println(index,value)
	}
}

fatiar

Uma fatia é uma referência a uma matriz, portanto, uma fatia se refere a esse tipo. O mecanismo de transferência de referência é seguido ao chamar uma função. A operação de uma fatia é igual a uma matriz, mas o comprimento da fatia pode ser alterado . É uma
sintaxe de definição de array de comprimento variável : var slice Name [] type (a diferença com array é que você não precisa especificar o comprimento)

ponto importante

1. Do nível inferior, uma fatia é na verdade uma estrutura de estrutura de dados com atributos como referência de matriz, comprimento, capacidade, etc.
2. O comprimento da fatia pode crescer dinamicamente
   s: = arr [0: fim] é equivalente a s: = arr [: fim]
   s: = arr [início: len (arr)] é equivalente a s: = arr [início:]
   s : = arr [0: len (arr)] é equivalente a s: = arr:]
3. Depois de concluída a definição da fatia, ela não pode ser usada. Deve ser usada para se referir a uma matriz ou criar um espaço para uso da fatia.
4. O fatiamento pode continuar a fatiar
5. Use a função incorporada append para
   anexar fatias dinamicamente. Append criará uma nova matriz e copiará os elementos da fatia original para a nova fatia. A fatia também é criada. O resultado do teste mostra que a fatia original permanece inalterada.
6. Conclua a cópia por meio da função embutida de cópia, copie os elementos de uma fatia para outra fatia e retorne o número de elementos atribuídos

Código de amostra

func test08(){
    
    
	var intArr = [...]int{
    
    1,2,3,4,5}
	fmt.Println(intArr)
	//定义切片方式1
	slice := intArr[1:3]
	fmt.Println(len(slice))//长度2
	fmt.Println(cap(slice))//容量4
	fmt.Println(slice) //2,3
	intArr[1] = 7
	fmt.Println(slice) //2,3 //修改原数组后 切边也会变

	s11 := intArr[:]
	s12 := append(s11,5,6,7,8) 
	//append 后产生新的切片，原切片不变
	fmt.Println(s11,s12)
	var ss0 = []int{
    
    1,2,3,4,5}
	var ss1 = make([]int,10)
	ss2 := copy(ss1,ss0)
	fmt.Printf("ss2类型 %T \n",ss2)//int
	fmt.Println("====>",ss0,ss1,ss2)
   
	//定义切片方式2  这种方式可以指定 切片的大小和容量
	// 这种方式定义的切片对应的数组是由make底层去维护，对外不可见
	var s2 [] int = make ([]int ,5,10)
	fmt.Println(len(s2))//5
	fmt.Println(cap(s2))//10
	fmt.Println(s2) //2,3

	//定义切片方式3
   //这种方式和make定义方式类似，
   var s1 []int =[]int{
    
    1,2,3,4,5}
   fmt.Println(cap(s1))//容量4
   fmt.Printf("s1类型 %T,slice类型 %T ,intArr类型%T \n",s1,slice,intArr)
	/*
		方式1 和方式2 的区别，
		方式1 直接引用数组，数组事先存在，程序员可见，修改原数组后 切片也会变
		方式2 make会自动创建一个数组由切片底层维护，程序员不可见
	*/
}

String e fatia

1. A camada inferior da string é uma matriz de bytes, portanto, também pode ser fatiada
2. A string é imutável. Se você precisar modificá-la, primeiro converta a string em uma matriz de bytes ou runa e, em seguida, reconstrua a string após a modificação.

str01 := "1231231";
strsl := str01[1:]
fmt.Println(strsl)//231231

Matriz bidimensional

Elemento é uma matriz de matriz unidimensional é uma
sintaxe de matriz bidimensional var 数组名[大小][大小]类型, como: var arr[2][2]int
Código de amostra

func test09(){
    
    
	//二维数组使用方式1
	//先声明再赋值
	var arr [2][3]int
	arr[0][1] = 10
	fmt.Println("二维数组长度",len(arr))
	fmt.Printf("arr[0]的地址 %p \n",&arr[0])
	fmt.Printf("arr[1]的地址 %p \n",&arr[1])
	//二维数组使用方式2
	//直接初始化 /四种方法
	var arr01 [2][3]int = [2][3]int{
    
    {
    
    1,2,3},{
    
    4,5,6}}
	var arr02 [2][3]int = [...][3]int{
    
    {
    
    1,2,3},{
    
    4,5,6}}
	var arr03 = [2][3]int{
    
    {
    
    1,2,3},{
    
    4,5,6}}
	var arr04 = [...][3]int{
    
    {
    
    1,2,3},{
    
    4,5,6}}
	
	fmt.Println(arr01,arr02,arr03,arr04);

	//遍历
	//双层for循环
	for i:=0;i<len(arr);i++{
    
    
		for j:=0;j<len(arr[i]);j++ {
    
    
			fmt.Println(i,j,"==>",arr[i][j])
		}
	}
	//for range
	for i,v := range arr{
    
    
		for j,v2 := range v{
    
    
			fmt.Println(i,j,"==>",v2)
		}
	}
}

mapa

Mapa é uma estrutura de dados de valor-chave, também conhecida como campo ou array associativo, semelhante à
sintaxe de declaração de coleção em outras linguagens de programaçãovar map 变量名 map[keytype]valuetype

A chave do mapa no Golang pode ser de vários tipos, como números bool, strings, ponteiros, canais, interfaces, estruturas e matrizes. Normalmente, as chaves são strings e ints. Slice, mapa e função não podem ser usados. porque não há como usar == para julgar.
essencialmente o mesmo tipo de chave e valor, normalmente digital, string, map, struct
Precauções

1. o mapa pode ser expandido automaticamente
2. Mapa é um tipo de referência. Alterar o valor do parâmetro do mapa na função afetará o conteúdo do mapa fora da função.

Código de amostra

func test12(){
    
    
	//map 排序 map是无序的，
	//排序是先将key 排序，再根据排序后的key获取值
	map1 := map[int]int{
    
    
		1:1,
		2:2,
		10:10,
		9:9,
	}
	//直接遍历
	for k,v := range map1{
    
    
		fmt.Println(k,v)
	}

	//排序遍历
	var keys []int
	for k,_ :=range map1{
    
    
		keys = append(keys,k)
	}
	sort.Ints(keys)
	fmt.Println(keys)
	for _,k := range keys{
    
    
		fmt.Println(k,map1[k])
	}
}
func test11(){
    
    
	//map切片
	var monsters []map[string]string
	monsters = make([]map[string]string,1)
	monsters[0] = make(map[string]string,2)
	monsters[0]["name"]="zhansan"
	monsters[0]["age"]="19"
	//由于切片容量为1 所以以下代码会报错
	//panic: runtime error: index out of range
	// monsters[1] = make(map[string]string,2)
	// monsters[1]["name"]="zhansan2"
	// monsters[1]["age"]="192"

	newMonster :=map[string]string{
    
    
		"name":"lisi",
		"age":"32",
	}

	monsters = append(monsters,newMonster)
	fmt.Println(monsters)


}
func test10(){
    
    
	//map 使用方式1
	var m map[string]string
	//声明后必须调用make 分配空间后才可以使用
	m = make(map[string]string,10)
	m["name"] = "zhangsan"
	m["age"] = "20"
	fmt.Println(m,len(m))

	//map使用方式2
	cities := make(map[string]string)
	cities["1"] = "北京"
	cities["2"] = "上海"
	cities["3"] = "天津"
	fmt.Println(cities,len(cities))

	//map使用方式3
	cities2 := map[string]string {
    
    
		"01" : "北京",
		"02" : "上海",
		"03" : "天津",
	}
	cities2["01"] = "北京01" //添加值
	fmt.Println(cities2,len(cities2))
	delete(cities2,"01")//删除值
	fmt.Println(cities2,len(cities2))

	val,ok := cities2["01"]//查询值
	if ok {
    
    
		fmt.Println("存在取值为：",val)
	}else{
    
    
		fmt.Println("值不存在：")
	}
	fmt.Println("=============>遍历")
	for k,v := range cities2{
    
    
		fmt.Println(k,v)
	}


}