数据结构

深入理解 Go 的内置数据结构与自定义类型

4 课时

数组与切片

数组在 Go 中是定长的，而切片是动态的、更灵活的数据结构。实际开发中，切片使用更为广泛。

切片是对底层数组的引用，包含三个要素：指针、长度和容量。

数组与切片基础

1package main
2 
3import "fmt"
4 
5func main() {
6    // 数组 - 固定长度
7    var arr [5]int = [5]int{1, 2, 3, 4, 5}
8    
9    // 切片 - 动态长度
10    slice := []int{1, 2, 3}
11    
12    // 从数组创建切片
13    s := arr[1:4] // [2, 3, 4]
14    
15    // make 创建切片
16    s2 := make([]int, 5, 10) // 长度5, 容量10
17    
18    // 追加元素
19    slice = append(slice, 4, 5)
20    
21    fmt.Println(arr, slice, s, s2)
22    fmt.Println(len(slice), cap(slice))
23}

Map 映射

Map 是 Go 中的哈希表实现，提供 O(1) 的查找、插入和删除操作。

注意：Map 的迭代顺序是不确定的，且 Map 是引用类型。

Map 操作

1package main
2 
3import "fmt"
4 
5func main() {
6    // 创建 map
7    m := make(map[string]int)
8    m["age"] = 25
9    
10    // 字面量初始化
11    scores := map[string]int{
12        "Alice": 90,
13        "Bob":   85,
14    }
15    
16    // 获取值
17    age := m["age"]
18    
19    // 检查键是否存在
20    score, ok := scores["Charlie"]
21    if !ok {
22        fmt.Println("Charlie 不存在")
23    }
24    
25    // 删除键
26    delete(scores, "Bob")
27    
28    // 遍历
29    for k, v := range scores {
30        fmt.Println(k, v)
31    }
32}

结构体

结构体是 Go 中组织数据的主要方式，类似于其他语言中的类。

Go 通过组合而非继承来实现代码复用。

结构体定义与使用

1package main
2 
3import "fmt"
4 
5// 定义结构体
6type User struct {
7    ID       int
8    Name     string
9    Email    string
10    IsActive bool
11}
12 
13// 方法
14func (u *User) Activate() {
15    u.IsActive = true
16}
17 
18func (u User) String() string {
19    return fmt.Sprintf("%s <%s>", u.Name, u.Email)
20}
21 
22func main() {
23    // 创建实例
24    user := User{
25        ID:    1,
26        Name:  "Alice",
27        Email: "alice@example.com",
28    }
29    
30    // 指针
31    userPtr := &User{Name: "Bob"}
32    
33    // 调用方法
34    user.Activate()
35    fmt.Println(user.String())
36}

结构体嵌入

1package main
2 
3import "fmt"
4 
5type Address struct {
6    City    string
7    Country string
8}
9 
10type Person struct {
11    Name string
12    Address // 嵌入结构体
13}
14 
15func main() {
16    p := Person{
17        Name: "Alice",
18        Address: Address{
19            City:    "Beijing",
20            Country: "China",
21        },
22    }
23    
24    // 直接访问嵌入字段
25    fmt.Println(p.City) // Beijing
26}

接口

接口是 Go 实现多态的方式。Go 的接口是隐式实现的，无需显式声明。

只要类型实现了接口定义的所有方法，就自动满足该接口。

接口定义与实现

1package main
2 
3import "fmt"
4 
5// 定义接口
6type Writer interface {
7    Write(data []byte) (int, error)
8}
9 
10type Reader interface {
11    Read(p []byte) (int, error)
12}
13 
14// 接口组合
15type ReadWriter interface {
16    Reader
17    Writer
18}
19 
20// 实现接口
21type FileWriter struct {
22    filename string
23}
24 
25func (f *FileWriter) Write(data []byte) (int, error) {
26    fmt.Printf("Writing to %s: %s
27", f.filename, data)
28    return len(data), nil
29}
30 
31func main() {
32    var w Writer = &FileWriter{filename: "test.txt"}
33    w.Write([]byte("Hello"))
34}

空接口与类型断言

1package main
2 
3import "fmt"
4 
5func describe(i interface{}) {
6    // 类型断言
7    if s, ok := i.(string); ok {
8        fmt.Println("String:", s)
9        return
10    }
11    
12    // 类型 switch
13    switch v := i.(type) {
14    case int:
15        fmt.Println("Int:", v)
16    case string:
17        fmt.Println("String:", v)
18    default:
19        fmt.Println("Unknown type")
20    }
21}
22 
23func main() {
24    describe(42)
25    describe("hello")
26    describe(true)
27}

1package main 2 3import "fmt" 4 5func main() { 6 // 数组 - 固定长度 7 var arr [5]int = [5]int{1, 2, 3, 4, 5} 8 9 // 切片 - 动态长度 10 slice := []int{1, 2, 3} 11 12 // 从数组创建切片 13 s := arr[1:4] // [2, 3, 4] 14 15 // make 创建切片 16 s2 := make([]int, 5, 10) // 长度5, 容量10 17 18 // 追加元素 19 slice = append(slice, 4, 5) 20 21 fmt.Println(arr, slice, s, s2) 22 fmt.Println(len(slice), cap(slice)) 23}

1package main 2 3import "fmt" 4 5func main() { 6 // 创建 map 7 m := make(map[string]int) 8 m["age"] = 25 9 10 // 字面量初始化 11 scores := map[string]int{ 12 "Alice": 90, 13 "Bob": 85, 14 } 15 16 // 获取值 17 age := m["age"] 18 19 // 检查键是否存在 20 score, ok := scores["Charlie"] 21 if !ok { 22 fmt.Println("Charlie 不存在") 23 } 24 25 // 删除键 26 delete(scores, "Bob") 27 28 // 遍历 29 for k, v := range scores { 30 fmt.Println(k, v) 31 } 32}

1package main 2 3import "fmt" 4 5// 定义结构体 6type User struct { 7 ID int 8 Name string 9 Email string 10 IsActive bool 11} 12 13// 方法 14func (u *User) Activate() { 15 u.IsActive = true 16} 17 18func (u User) String() string { 19 return fmt.Sprintf("%s <%s>", u.Name, u.Email) 20} 21 22func main() { 23 // 创建实例 24 user := User{ 25 ID: 1, 26 Name: "Alice", 27 Email: "alice@example.com", 28 } 29 30 // 指针 31 userPtr := &User{Name: "Bob"} 32 33 // 调用方法 34 user.Activate() 35 fmt.Println(user.String()) 36}

1package main 2 3import "fmt" 4 5type Address struct { 6 City string 7 Country string 8} 9 10type Person struct { 11 Name string 12 Address // 嵌入结构体 13} 14 15func main() { 16 p := Person{ 17 Name: "Alice", 18 Address: Address{ 19 City: "Beijing", 20 Country: "China", 21 }, 22 } 23 24 // 直接访问嵌入字段 25 fmt.Println(p.City) // Beijing 26}

1package main 2 3import "fmt" 4 5// 定义接口 6type Writer interface { 7 Write(data []byte) (int, error) 8} 9 10type Reader interface { 11 Read(p []byte) (int, error) 12} 13 14// 接口组合 15type ReadWriter interface { 16 Reader 17 Writer 18} 19 20// 实现接口 21type FileWriter struct { 22 filename string 23} 24 25func (f *FileWriter) Write(data []byte) (int, error) { 26 fmt.Printf("Writing to %s: %s 27", f.filename, data) 28 return len(data), nil 29} 30 31func main() { 32 var w Writer = &FileWriter{filename: "test.txt"} 33 w.Write([]byte("Hello")) 34}

1package main 2 3import "fmt" 4 5func describe(i interface{}) { 6 // 类型断言 7 if s, ok := i.(string); ok { 8 fmt.Println("String:", s) 9 return 10 } 11 12 // 类型 switch 13 switch v := i.(type) { 14 case int: 15 fmt.Println("Int:", v) 16 case string: 17 fmt.Println("String:", v) 18 default: 19 fmt.Println("Unknown type") 20 } 21} 22 23func main() { 24 describe(42) 25 describe("hello") 26 describe(true) 27}