06 數組、切片和map

文章目錄

• 數組
• 切片
• String和slice
• 二維數組
• map

數組

數組可以存放多個相同類型的資料

數組定義：var 數組名[數組大小] 資料類型

數組元素的通路：數組名[下标] ，下标從0 開始

數組的位址可以通過 數組名來獲得 &數組名

數組中各個元素位址間隔是根據數組中資料類型決定的 ，如：int64 ->8 int32->4

注意事項

1. 一旦聲明數組長度固定不能動态變化
2. var arr[] int 這樣定義時，其實是定義了一個切片
3. 數組中的元素可以是任何資料類型，但是不能混用
4. 數組建立後如果沒有指派，預設存放是的 該資料類型的預設值

5. 數組作為參數時，是值傳遞 （指派新值），如果想在其他方法中修改數組，需要通過指針來操作

   6. 數組的長度是數組的一部分，長度不符的數組不能傳遞給函數使用。

示例代碼

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)
	}
}
           

切片

切片是一個數組的引用，是以切片是引用該類型，調用函數時遵循引用傳遞的機制，切片的操作和數組一樣，但是切片長度是可以變化的，是一個長度可變的數組

定義文法：var 切片名[] 類型 (和數組的不同之處在于 不用指定長度)

注意點

1. 從底層來說，切片其實就是一個資料結構struct ，擁有數組引用、長度、容量等屬性

2. 切片長度可以動态增長

   s := arr[0:end] 等同于 s := arr[:end]

   s := arr[start:len(arr)] 等同于 s := arr[start:]

   s := arr[0:len(arr)] 等同于 s := arr:]

3. 切片定義完成後，不能使用，必須讓它引用一個數組，或者make一個空間供切片使用
4. 切片可以繼續切片

5. 使用append内置函數可以對切片進行動态追加

   append會建立一個新的數組，将原切片中的元素複制到新的切片中，切片也建立了，測試結果 顯示原切片保持不變，

6. 通過copy 内置函數 完成拷貝,将一個切片中的元素複制到另外一個切片中，傳回指派的元素個數

示例代碼

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和slice

1. string 底層是一個byte數組，是以也可以進行切片處理
2. string 是不可變的，如果需要修改字元串，需要先吧string轉換為 byte數組，或者rune數組，修改後重建字元串。

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

二維數組

元素是一維數組的數組就是二維數組

文法

var 數組名[大小][大小]類型

如：

var arr[2][2]int

示例代碼

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)
		}
	}
}
           

map

map 是 key-value 資料結構，又稱為字段或者關聯數組，類似于其他程式設計語言中的集合

聲明文法

var map 變量名 map[keytype]valuetype

Golang中 map 的key可以是多種類型，如：bool 數字，string，指針，channel,還可以是接口、結構體、數組 ,通常情況下 key 為 字元串和int,slice 、map 和function 不可以做key,因為沒有辦法使用 == 來判斷。

value 類型和key基本一樣，通常為數字、string、map、struct

注意點

1. map 可以自動擴容
2. map是引用類型 ，函數内次改map參數的值，會影響函數外map的内容

示例代碼

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)
	}


}