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
	*/

}