go基础笔记----内建容器

• 数组

package main

import "fmt"

// 求数组最大值
func maxValue(arr []int) (int, int) {
	maxi := -1
	maxValue := -1
	for i, val := range arr {
		if val > maxValue {
			maxi, maxValue = i, val
		}
	}
	return maxi, maxValue
}

func printArray(arr *[5]int) {
	for i, v := range arr {
		fmt.Println(i, v)
	}
}

func main() {
	// go语言中一般不适用数组，一般使用切片
	// 定义数组
	var arr1 [5]int
	arr2 := [3]int{1, 2, 3}          // := 要赋初始值
	arr3 := [...]int{3, 4, 4, 6, 76} //让编译器来计算数量

	// 二维数组
	var grid [4][5]int //4个长度为5的int数组

	fmt.Println(arr1, arr2, arr3)
	fmt.Println(grid)

	// for循环遍历数组
	for i := 0; i < len(arr3); i++ {
		fmt.Println(arr3[i])
	}

	// range遍历数组
	for _, v := range arr3 {
		fmt.Println(v)
	}

	/* php foreach遍历数组
	foreach(array as $k=>$v)
	{
		echo $k;
		echo $v
	}*/

	// 数组求最大值 通过切片传递
	fmt.Println(maxValue(arr3[:]))

	// 数组是值类型,也就是传输方式会是拷贝而不是修改元数据,想类似于引用传递可以使用指针
	printArray(&arr3)

}

• 切片与切片操作

package main

import "fmt"

func updateSlice(s []int) {
	s[0] = 100
}

func printSlice(s []int) {
	fmt.Printf("%v, len=%d, cap=%d\n", s, len(s), cap(s))
}

//Slice 切片（很重要） 前闭后开
func main() {
	// 定义array
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}

	// 取切片Slice Slice是对原本array的view,类似于引用
	fmt.Println("arr[2:6] :", arr[2:6]) // print [2 3 4 5]
	fmt.Println("arr[:6] :", arr[:6])   // print [0 1 2 3 4 5]
	fmt.Println("arr[2:] :", arr[2:])   // print [2 3 4 5 6 7]
	fmt.Println("arr[:] :", arr[:])     // print [0 1 2 3 4 5 6 7]

	s1 := arr[2:]
	fmt.Println("s1 =", s1)

	s2 := arr[:]
	fmt.Println("s2 =", s2)

	fmt.Println("After updateSlice(s1)")
	updateSlice(s1)
	fmt.Println(s1)
	fmt.Println(arr)

	fmt.Println("After updateSlice(s2)")
	updateSlice(s2)
	fmt.Println(s2)
	fmt.Println(arr)

	// 切片重组 reslice
	fmt.Println("reslice")
	fmt.Println(s2)
	s2 = s2[:5]
	fmt.Println(s2)
	s2 = s2[2:]
	fmt.Println(s2)

	// Slice拓展 slice底层实现包括 1.ptr:指针 2.len:数组长度 3.cap:在cap范围内都可以进行拓展
	// slice可以向后拓展,不可以向前拓展. s[i]不可以超越len(s),向后拓展不可以超越底层数组cap(s)
	fmt.Println("Extending slice")
	fmt.Println(arr)
	arr[0], arr[2] = 0, 2
	s1 = arr[2:6] // print [2 3 4 5]
	s2 = s1[3:5]  // print [5 6]
	fmt.Println("arr =", arr)
	fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d \n",
		s1, len(s1), cap(s1)) // s1=[2 3 4 5], len(s1)=4, cap(s1)=6
	fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d \n",
		s2, len(s2), cap(s2)) // s2=[5 6], len(s2)=2, cap(s2)=3

	// slice append
	fmt.Println("append start")
	fmt.Println(s2)
	s3 := append(s2, 10)
	s4 := append(s3, 11)
	s5 := append(s4, 12)
	fmt.Println("s3, s4, s5 =", s3, s4, s5)
	// s4 and s5 no longer view arr 系统开辟空间填充数据
	// 添加元素时如果超越cap, system会重新分配更大的底层数组，将原来的元素拷贝过去，如果原数组被用到则存在，否则垃圾回收掉
	// 由于值传递的关系，必须接收append的值  s = append(s, val)
	fmt.Println("arr =", arr)

	// 创建slice
	// 1
	var s []int // Zero value for slice is nil  s == nil
	for i := 0; i < 100; i++ {
		printSlice(s) //cap扩充为*2扩充
		s = append(s, 2*i+1)
	}
	fmt.Println(s)

	// 新建有初始值的slice
	st := []int{2, 4, 6, 8}
	printSlice(st)

	// 新建固定长度的slice 第一个参数为len长度，第二个为cap的长度，默认填写一个会新建len=cap的slice
	st1 := make([]int, 16, 32)
	printSlice(st1)

	// slice复制
	copy(st1, st)
	printSlice(st1)

	// slice删除
	st1 = append(st1[:3], st1[4:]...)
	printSlice(st1)

	// 删除slice头
	front := st1[0]
	st1 = st1[1:]
	println(front)
	printSlice(st1)

	// 删除slice尾
	tail := st1[len(st1)-1]
	st1 = st1[:len(st1)-1]
	println(tail)
	printSlice(st1)

}

• map与例题

package main

import (
	"fmt"
	"unicode/utf8"
)

// 寻找最长不含有重复字符的字串
func lengthOfNonRepeatingSubStr(s string) int {
	// map
	lastOccurred := make(map[byte]int)
	// 开始
	start := 0
	// 最大长度
	maxLength := 0
	// i为字符的位置 ch为字符的access码值
	for i, ch := range []byte(s) {
		// 判断map里面是否有当前字符
		lastI, ok := lastOccurred[ch]
		if ok && lastI >= start {
			start = lastOccurred[ch] + 1
		}
		if i-start+1 > maxLength {
			maxLength = i - start + 1
		}
		lastOccurred[ch] = i
		fmt.Println(lastOccurred)
	}
	return maxLength
}

// 寻找最长不含有重复字符的字串（国际版）
func lengthOfNonRepeatingWorldSubStr(s string) int {
	// map
	lastOccurred := make(map[rune]int)
	// 开始
	start := 0
	// 最大长度
	maxLength := 0
	// i为字符的位置 ch为字符的access码值
	for i, ch := range []rune(s) {
		// 判断map里面是否有当前字符
		lastI, ok := lastOccurred[ch]
		if ok && lastI >= start {
			start = lastOccurred[ch] + 1
		}
		if i-start+1 > maxLength {
			maxLength = i - start + 1
		}
		lastOccurred[ch] = i
		fmt.Println(lastOccurred)
	}
	return maxLength
}

func main() {
	/*
		   定义map格式
		   m := map[key_type]value_type {
			   "key": "value",
			   "key": "value",
		   }
		   复合map定义
		   map[key1]map[k2]value
	*/
	m := map[string]string{ // key在map里面是无序的
		"lmf": "lfx",
		"yxs": "xd",
	}

	fmt.Println(m)

	m2 := make(map[string]int) // m2 == empty map
	fmt.Println(m2)

	var m3 map[string]int // m3 == nil
	fmt.Println(m3)

	// 遍历map
	fmt.Println("Traversing map")
	for k, v := range m {
		fmt.Println(k, v)
	}

	// 获取map值 如何不存在key则返回空值
	fmt.Println("Getting values")
	if lmf, ok := m["lmf"]; ok {
		fmt.Println("map key exist")
		fmt.Println(lmf)
	} else {
		fmt.Println("map key does not exist")
	}

	// map删除元素
	fmt.Println("Deleteing values")
	delete(m, "lmf")
	for k, v := range m {
		fmt.Println(k, v)
	}

	// map key 类型
	// map使用哈希表，必须可以比较相等.  除了slice,map,function的内建类型都可以作为key.  struct类型不包含上述字段，也可以作为key

	// 寻找最长不含有重复字符的字串
	fmt.Println(lengthOfNonRepeatingSubStr("pwwwkew"))

	/*
	 rune相当于go的char
	 使用range来遍历[]rune[str] rune对
	 使用utf8.RuneCountInString获得字符数量，使用len()获得的是字节长度
	 使用[]byte获得字节
	 使用range []rune[str]会重新开辟一块run slice内存
	*/
	sr := "Yes我爱慕课网!" // UTF-8
	for _, b := range []byte(sr) {
		fmt.Printf("%X", b)
	}

	fmt.Println()
	for i, ch := range sr { // ch is a rune
		fmt.Printf("(%d %x)", i, ch)
	}

	fmt.Println()
	fmt.Println("Rune count:",
		utf8.RuneCountInString(sr))

	bytes := []byte(sr)
	for len(bytes) > 0 {
		ch, size := utf8.DecodeRune(bytes)
		bytes = bytes[size:]
		fmt.Printf("%c ", ch)
	}

	fmt.Println()
	for i, ch := range []rune(sr) { //重新开辟一块rune内存，也是将uncode转utf-8
		fmt.Printf("(%d %c) ", i, ch)
	}

	fmt.Println("\n World lenght ")
	// 国际版查找最长字符字串长度
	fmt.Println(lengthOfNonRepeatingWorldSubStr("我爱你祖国国2"))
	fmt.Println()

	//字符串操作 strings Fields(去除空格),Split,Join，Contains,Index,Tolower,ToUpper,Trim,TrimRight,TrimLeft
	/*
		// 子串substr在s中，返回true
		func Contains(s, substr string) bool
		// chars中任何一个Unicode代码点在s中，返回true
		func ContainsAny(s, chars string) bool
		// Unicode代码点r在s中，返回true
		func ContainsRune(s string, r rune) bool
	*/

}