数组与动态数组

数组声明与遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//数组声明
	var myArray1 [10]int
	或
	myArray2 [10]int{1,2,3,4}

//遍历数组元素
	for i:=0;i<10;i++{
		fmt.Println(myArray1[i])
	}
	
//按值与索引遍历
	for index,value := range myArray2{
		fmt.Println(index,value)
	}

数组传参建议使用动态数组Slice。

1
2
3
4
5
6
7
8
9
10
//动态数组声明
	
	myArray :=[]int{1,2,3,4} 
	
//动态数组为地址传递，数组则仅数值传递
	func test(myArray []int){

		myArray[0]=1  //地址传递，函数外生效
		...
	}

Slice切片声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//Slice切片声明 1: 使用":"推断声明

	slice1 ：= []int{1,2,3,4,5}
	
//Slice声明 2: 变量var声明，声明后变量并不分配空间
	
	var slice2 []int

	slice2=make([]int,5) //使用make为slice2分配5个空间。

//slice声明 3: 使用var与make联合声明

	var slice3 []int=make([] int,3)

//slice声明 4: 使用":"与make联合声明
	
	slice4 :=make([] int,3)

//slice判空
	if(slice == nil){
        fmt.Println("null")
    }

Slice的截取与追加

len与cap的区别：
  • len为数组首指针到尾指针之间的长度，为数组中已分配的空间长度。
  • cap为数组首指针到数组底层的长度，为该数组的最大长度。
使用append为动态数组追加元素。
1
2
3
4
5
//使用append追加数组长度时，若追加后长度大于cap，则将cap设为原cap值的两倍

	slice:=make([]int,3)

	slice=append(slice,1)

具体切片方法类似于Python数组的切片方法。

copy函数的使用
1
2
3
4
5
6
7
//将底层数组的slice进行拷贝
	s1 := []int{1,2,3}
	
	s2 := make([]int,3)
	
	copy(s2,s1)
//此时指向s1与s2的指针不同

Map的定义与使用

类似于Python中的字典,结构为键值对。([键:值])

1
2
3
4
5
6
7
8
9
10
11
12
13
//类似于slice声明,使用make为变量分配空间

	myMap1 :=make(map[string]string,10)

	myMap1["key"]="values"
或
    myMap2:=map[string]string{

        1:"values1"
        2:"values2"
        3:"values3"
        ...
    }
对Map的操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//添加

    myMap["keys"]=["values"]
//遍历

    for key,value:=range myMap{
        fmt.Println(key)
        fmt.Println(value)
    }
//删除

    delete(myMap,"keys")
//修改:map类型使用引用传递

    myMap["newKeys"]=["newValues"]