04-内建内容

1. 数组

1.1 定义数组

var arr1 [5]int
arr2 := [3]int{1, 3, 5}
arr3 := [...]int{2, 4, 6, 8, 10}
var grid [4][5]int

• 数量写在类型前

1.2 遍历数组

for i := 0; i < len(arr);i++ {
	fmt.Println(arr[i])
}

for i, v := range arr {
		fmt.Println(i, v)
}
	
for _, v := range arr {
		fmt.Println(v)
}

• 可通过_省略变量
• 不仅range，任何地方都可以通过_省略变量
• 如果只要i，可以写成for i := range arr

1.3 数组是值类型

• [10]int和[20]int是不同类型
• 调用func f(arr [10] int) 会拷贝数组
• 在go语言中一般不直接使用数组

2. Slice（切片）

2.1 Slice定义与更新

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

func main() {
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}

	fmt.Println("arr[2:6] =", arr[2:6])
	fmt.Println("arr[:6] =", arr[:6])
	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)
}

• Slice本身没有数据，是对底层array的一个view
• Reslice

fmt.Println("Reslice")
fmt.Println(s2)
s2 = s2[:5]
fmt.Println(s2)
s2 = s2[2:]
fmt.Println(s2)

2.2 Slice扩展

fmt.Println("Extending slice")
arr[0], arr[2] = 0, 2
fmt.Println("arr =", arr)
s1 = arr[2:6]
s2 = s1[3:5] // [s1[3], s1[4]]
fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d\n",
	s1, len(s1), cap(s1))
fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d\n",
	s2, len(s2), cap(s2))

• Slice可以向后扩展，但不可以向前扩展
• s[i]不可以超越len(s)，向后扩展不可以超越底层数组cap(s)

2.3 向Slice添加元素

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.
fmt.Println("arr =", arr)

// Uncomment to run sliceOps demo.
// If we see undefined: sliceOps
// please try go run slices.go sliceops.go
fmt.Println("Uncomment to see sliceOps demo")
// sliceOps()

• 添加元素时如果超越cap，系统会重新分配更大的底层数组
• 由于值传递的关系，必须接收append的返回值
• s = append(s,val)

2.4 Slice操作

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

func main() {
	fmt.Println("Creating slice")
	var s []int // Zero value for slice is nil

	for i := 0; i < 100; i++ {
		printSlice(s)
		s = append(s, 2*i+1)
	}
	fmt.Println(s)

	s1 := []int{2, 4, 6, 8}
	printSlice(s1)

	s2 := make([]int, 16)
	s3 := make([]int, 10, 32)
	printSlice(s2)
	printSlice(s3)

	fmt.Println("Copying slice")
	copy(s2, s1)
	printSlice(s2)

	fmt.Println("Deleting elements from slice")
	s2 = append(s2[:3], s2[4:]...)
	printSlice(s2)

	fmt.Println("Popping from front")
	front := s2[0]
	s2 = s2[1:]

	fmt.Println(front)
	printSlice(s2)

	fmt.Println("Popping from back")
	tail := s2[len(s2)-1]
	s2 = s2[:len(s2)-1]

	fmt.Println(tail)
	printSlice(s2)
}

3. Map

3.1 Map定义

map [k] v, map[k1] map[k2] v

m := map[string]string{
	"name":    "ccmouse",
	"course":  "golang",
	"site":    "imooc",
	"quality": "notbad",
}

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

var m3 map[string]int // m3 == nil

3.2 Map遍历

for k, v := range m {
		fmt.Println(k, v)
}

3.3 Map操作

fmt.Println("Getting values")
courseName := m["course"]
fmt.Println(`m["course"] =`, courseName)
if causeName, ok := m["cause"]; ok {
	fmt.Println(causeName)
} else {
	fmt.Println("key 'cause' does not exist")
}

fmt.Println("Deleting values")
name, ok := m["name"]
fmt.Printf("m[%q] before delete: %q, %v\n",
	"name", name, ok)

delete(m, "name")
name, ok = m["name"]
fmt.Printf("m[%q] after delete: %q, %v\n",
	"name", name, ok)

3.4 Map的key

3.5 例题：寻找最长不含有重复字符的子串

分析：

func lengthOfNonRepeatingSubStr(s string) int {
	lastOccurred := make(map[rune]int)
	start := 0
	maxLength := 0

	for i, ch := range []rune(s) {
		if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
			start = lastI + 1
		}
		if i-start+1 > maxLength {
			maxLength = i - start + 1
		}
		lastOccurred[ch] = i
	}

	return maxLength
}

3.6 字符和字符串处理rune