吕滔博客

基于不讲，介绍一种让编译器自动识别的写法[...]

func main() {
	var numArray = [...]int{1, 2}
	fmt.Println(numArray)   //[1 2]
	fmt.Printf("type of numArray:%T\n", numArray)  //type of numArray:[2]int

	var cityArray = [...]string{"北京", "上海", "深圳"}
	fmt.Println(cityArray)   //[北京 上海 深圳]
	fmt.Printf("type of cityArray:%T\n", cityArray)  //type of cityArray:[3]string
}

普通遍历

func main() {
	var a = [...]string{"北京", "上海", "深圳"}
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}
}
/*
北京
上海
深圳
 */

kv遍历

func main() {
	var a = [...]string{"北京", "上海", "深圳"}
	for index, value := range a {
		fmt.Println(index, value)
	}
}
/*
0 北京
1 上海
2 深圳
 */

多维数组

func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(a)         //[[北京 上海] [广州 深圳] [成都 重庆]]
	fmt.Println(a[2][1])     //支持索引取值:重庆
}

遍历多维数组

func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	for _, v1 := range a {   // v1 = [北京 上海]
		for _, v2 := range v1 {
			fmt.Println(v2)
		}
	}
}
/*
北京
上海
广州
深圳
成都
重庆
*/

练习：求和

func main() {
	var intArr2 [5]int = [...]int {1, -1, 9, 90, 12}
	sum := 0
	for _, val := range intArr2 {
		//累计求和
		sum += val
	}
    
	//如何让平均值保留到小数.
	fmt.Printf("sum=%v 平均值=%v \n\n", sum, float64(sum) / float64(len(intArr2)))
	// sum=111 平均值=22.2 
}

练习：找最大值

1、声明一个数组var intArr[5] = [...]int {1, -1, 12, 65, 11}
2、假定第一个元素就是最大值，下标就 0
3、然后从第二个元素开始循环比较，如果发现有更大，则交换

func main() {
	var intArr = [...]int{1, -1, 112, 65, 11}
	maxValue := intArr[0]
	maxIndex := 0
	for i := 0; i < len(intArr); i++ {
		if maxValue < intArr[i] {
			maxValue = intArr[i]
			maxIndex = i
		}
	}
	fmt.Println("最大值", maxValue, "最大值索引值", maxIndex)
	// 最大值 112 最大值索引值 2
}

切片的基础语法：

// var name []T
// 1、name:表示变量名
// 2、T:表示切片中的元素类型

使用make构造切片 格式：make([]T, size, cap)

• T:切片的元素类型
• size:切片中元素的数量
• cap:切片的容量

func main() {
	a := make([]int, 2, 10)
	fmt.Println(a)         //[0 0]
	fmt.Println(len(a))     //2
	fmt.Println(cap(a))     //10
}

切片可理解为可变数组，是数组的升级封装.支持扩容
切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。
举个例子，现在有一个数组 a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片 s1 := a[:5]，相应示意图如下。

切片s2 := a[3:6]，相应示意图如下

切片的长度和容量

• 切片拥有自己的长度和容量，我们可以通过使用内置的 **len()**函数求长度，使用内置的 **cap()**函数求切片的容量。
• 切片的长度就是它所包含的元素个数。
• 切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
• 切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	fmt.Printf("长度:%v 容量 %v\n", len(s), cap(s))  // 长度:6 容量 6

	c := s[:2]
	fmt.Println(c)          // [2 3]
	fmt.Printf("长度:%v 容量 %v\n", len(c), cap(c))   // 长度:2 容量 6

	d := s[1:3]
	fmt.Println(d)         // [3 5]
	fmt.Printf("长度:%v 容量 %v", len(d), cap(d))    // 长度:2 容量 5
}

基本遍历

func main() {
	var a = []string{"北京", "上海", "深圳"}
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}
}
/*
北京
上海
深圳
 */

kv遍历

func main() {
	var a = []string{"北京", "上海", "深圳"}
	for index, value := range a {
		fmt.Println(index, value)
	}
}
/*
0 北京
1 上海
2 深圳
 */

切片追加append()

• Go 语言的内建函数 append()可以为切片动态添加元素，每个切片会指向一个底层数组
• 这个数组的容量够用就添加新增元素。
• 当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。
• “扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收 append 函数的返回值。

func main() {
	// append()添加元素和切片扩容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v len:%d cap:%d ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

追加多个

func main() {
	var citySlice []string
	citySlice = append(citySlice, "北京")	// 追加一个元素
	citySlice = append(citySlice, "上海", "广州", "深圳")	// 追加多个元素

	a := []string{"成都", "重庆"}
	citySlice = append(citySlice, a...)    // 追加切片

	fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]
}

删除元素

func main() {
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	a = append(a[:2], a[3:]...)	      // 要删除索引为 2 的元素
	fmt.Println(a)                //[30 31 33 34 35 36 37]
}

切片合并

func main() {
	arr1 := []int{2,7,1}
	arr2 := []int{5,9,3}
	fmt.Println(arr2,arr1)
	arr1 = append(arr1, arr2...)
	fmt.Println(arr1)  // [2 7 1 5 9 3]
}

切片copy()

问题：

func main() {
	a := []int{1, 2, 3, 4, 5}
	b := a
	fmt.Println(a)   //[1 2 3 4 5]
	fmt.Println(b)   //[1 2 3 4 5]
	b[0] = 1000
	fmt.Println(a)   //[1000 2 3 4 5]
	fmt.Println(b)   //[1000 2 3 4 5]
}

copy()函数

• Go 语言内建的 copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中
• copy()函数的使用格式如下： copy(destSlice, srcSlice []T)

其中：
srcSlice: 数据来源切片
destSlice: 目标切片

func main() {
	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)    // [0 0 0 0 0]
	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]
}

正序排序

• 对于 int 、 float64 和 string 数组或是切片的排序
• go 分别提供了 sort.Ints() 、sort.Float64s() 和 sort.Strings() 函数， 默认都是从小到大排序

func main() {
	intList := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
	sort.Ints(intList)
	fmt.Println(intList)   // [0 1 2 3 4 5 6 7 8 9]

	stringList := []string{"a", "c", "b", "z", "x", "w", "y", "d", "f", "i"}
	sort.Strings(stringList)
	fmt.Println(stringList)   // [a b c d f i w x y z]
}

sort 降序排序

• Golang的sort 包 可 以 使 用 sort.Reverse(slice) 来 调 换slice.Interface.Less
• 也就是比较函数，所以， int 、 float64 和 string的逆序排序函数可以这么写

func main() {
	intList := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
	sort.Sort(sort.Reverse(sort.IntSlice(intList)))
	fmt.Println(intList)   // [9 8 7 6 5 4 3 2 1 0]

	stringList := []string{"a", "c", "b", "z", "x", "w", "y", "d", "f", "i"}
	sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
	fmt.Println(stringList)   // [z y x w i f d c b a]
}