每種語言在實現資料結構有些許不同。go 是如何實現的呢？
1. 陣列 array
package main
import "fmt"
func main()
x[3] = 4 // [1 2 0 4 0 0 0]
// x[8] = 8 越界無法通過編譯
a := [3]int
b := [...]int // 型別推導
// x 和 a,b 是兩種不同的資料型別
// 編譯器會把 b陣列 翻譯成 a 這種型別。
fmt.printf("%t\n", x)
fmt.printf("%t\n", a)
fmt.printf("%t\n", b)
fmt.println(x)
fmt.println(a)
fmt.println(b)
}e:>go run main.go
[7]int
[3]int
[3]int
[1 2 0 4 0 0 0]
[1 2 3]
[1 2 3]
通常有三種方式獲取乙個切片：
從乙個陣列
使用字面量初始化切片
make 關鍵字建立切片
也可以從乙個切片獲取切片（切片再切片）
package main
import "fmt"
func main ()
fmt.printf("array type is :%t; value is %s\n",array,array)
// 1. 從陣列獲取乙個切片
s1 := array[0:3]
fmt.printf("s1 type is :%t; value is %s\n",s1,s1)
s11 := s1[0:2] // 切片再切片
fmt.printf("s11 type is :%t; value is %s\n",s11,s11)
s1[0] = "aa" // 切片再切片時，底層切片修改的元素的值, 新切片的值也會隨著改變
s11[1] = "bb" // 切片再切片時，新切片修改的元素的值, 底層切片的值也會隨著改變
fmt.printf("### s1 type is :%t; value is %s\n",s1,s1)
fmt.printf("### s11 type is :%t; value is %s\n",s11,s11)
// 2. 從字面量初始化
s2 := string
fmt.printf("s2 type is :%t; value is %s\n",s2,s2)
s22 := s2[0:2]
fmt.printf("s22 type is :%t; value is %s\n",s22,s22)
s2[0] = "xx" // 切片再切片時，底層切片修改的元素的值, 新切片的值也會隨著改變
fmt.printf("### s2 type is :%t; value is %s\n",s2,s2)
fmt.printf("### s22 type is :%t; value is %s\n",s22,s22)
// 3. make 函式初始化
s3 := make(int,5,10)
s3[1] = 2
fmt.printf("s3 type is :%t; value is %d\n",s3,s3)
}e:>go run slice.go
array type is :[5]string; value is [a b c d e]
s1 type is :string; value is [a b c]
s11 type is :string; value is [a b]
### s1 type is :string; value is [aa bb c]
### s11 type is :string; value is [aa bb]
s2 type is :string; value is [x y z n]
s22 type is :string; value is [x y]
### s2 type is :string; value is [xx y z n]
### s22 type is :string; value is [xx y]
s3 type is :int; value is [0 2 0 0 0]
s5 := int
//s6 := make(int,10,10)
s6 := int
copy(s6,s5)
fmt.println(s5,s6) // [1 3 5] [1 3 5 8 10]
複製整個大切片，消耗記憶體較多，應該避免此類操作影響程式的效能。
雜湊函式和解決雜湊衝突是實現乙個效能優異的雜湊表的關鍵：理想的情況下，雜湊函式應該能將不同的鍵對映到不同的索引上，這就要求雜湊函式的輸出範圍要大於輸入範圍，但是由於
鍵的數量會遠遠大於對映的範圍，所以在實際使用時這個效果不可能實現。比較實際的方式是讓雜湊函式的結果盡可能的均勻分布，然後通過工程手段解決雜湊衝突的問題。不均勻的雜湊
的雜湊函式讀寫效能可能會達到 o(n)。在完美的雜湊函式，當鍵的數量足夠多是也會產生衝突。開放定址法和拉鍊法是解決雜湊衝突常用的兩種方式。大多數程式語言和資料庫通常會選擇
拉鍊發解決衝突，開放定址法解決衝突底層用的依然陣列，而拉鍊法用 陣列+鍊錶 實現了乙個 雜湊桶，相當於乙個二位陣列，衝突時放到桶裡，而查詢時只需要遍歷這個鍊錶（桶），但
通常鍊錶的長度控制在4以內，否則效能不太高。
有兩種方式得到乙個 map:
package main
import (
"fmt"
)func main()
// make 函式生成 map
m2 := make(map[int]string)
m2[1] = "a"
m2[2] = "b"
m2[3] = "c"
fmt.printf("%#v\n",m1)
"%#v\n",m2)
// 遍歷 map
for i:=1;i<=len(m2);i++
fmt.println(i,m2[i])
} // 刪除 元素
delete(m1,1)
fmt.printf("%#v\n",m1)
// v,ok 判斷 key 是否存在
v,ok := m1[1]
if !ok else
}
package main
import "fmt"
func main()
golang資料結構
常見的資料結構有陣列 切片 map 結構體。陣列是乙個由固定長度的特定型別元素組成的序列，乙個陣列可以由零個或多個元素組成。陣列的宣告語法如下 var variable name size variable type陣列變數名 陣列宣告及使用時的變數名。元素數量 陣列的元素數量，可以是乙個表示式，但...
golang基礎資料結構
這裡主要討論四種型別 陣列 slice map和結構體 陣列和結構體是聚合型別 它們的值都是由很多個元素或者成員欄位的值組成。陣列是有同構元素組成 每個陣列的元素的型別相同 結構體為異構元素組成 每個結構體不一定是同型別元素構成 陣列和結構體都是有固定記憶體大小的資料結構 slice和map則是動態...
Golang 資料結構 字典
字典儲存 key,value 對，go提供了非常方便的實現，內建的map型別。本文增強內建的map型別，新增便捷的操作用於獲取或改變其內容。建立itemdictionary泛型 併發安全的，能夠生成任何具體型別。通過dict valuedictionary 建立字典，提供一組暴露方法 測試 描述如何...