标签：

1、数组（Array）

数组是一个有相同数据类型的元素组成的固定长度的有序集合，如：var x [5]int，使用var定义的数组，默认值如果整型为0，浮点型为0.0，字符串为""，对象为nil。

求整型数组之和，使用range函数，遍历数组、切片、字典时，返回索引和元素值；当对某个返回值不感兴趣时，要用下划线（_）来代替

package main

import "fmt"

func main() {
    var x [5]int
    x[0] = 2
    x[1] = 3
    x[2] = 3
    var sum int
    for _, elem := range x {
        sum += elem
    }
    fmt.Println(sum)
}

定义数组其他方式：1）、var x = [5]int{1,2,3,4,5}

　　　　　　　　　2）、var x =[5]int{}

　　　　　　　　　　　  x[0]=1

　　　　　　　　　3）、var x = [...]string{　　　　　　　　　　　　　　　　　var x = [...]string{
　　　　　　　　　　　　　　"Monday",　　　　　　　　　　　　　　　　　　　　"Monday",　

　　　　　　　　　　　　　　"Tuesday"　　　　　　　　　　　　　　　　　　　　"Tuesday",//可以带着英文逗号
　　　　　　　　　　　　}　　　　　　　　　　　　　　　　　　　　　　　　}

2、切片（Slice）

切片类似数组，切片长度是可变的；切片是有容量（capacity）和长度（length）两个属性的；切片变量使用时，索引不能大于等于切片长度，否则报错out of range

1）、make函数定义切片

package main

import "fmt"

func main() {
    var x = make([]float64, 5) //切片的容量和长度都是5
    fmt.Println("Capacity:", cap(x), "Length:", len(x))
    var y = make([]float64, 5, 10) //切片容量为10，长度为5
    fmt.Println("Capacity:", cap(y), "Length:", len(y))

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

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

输出如图：

2）、通过数组切片赋值，采用[low_index:high_index]方式截取数组来获取数值切片，其中获取包括low_index，不包括high_index，high_index不能大于数组长度

使用案例如下

package main

import "fmt"

func main() {
    var arr1 = [5]int{1, 2, 3, 4, 5}
    var s1 = arr1[2:3]
    var s2 = arr1[:3]
    var s3 = arr1[2:]
    var s4 = arr1[:]
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(s4)
}

运行结果如下

3）、切片长度可变性，使用append函数

package main

import "fmt"

func main() {
    var arr1 = make([]int, 5, 10)
    for i := 0; i < len(arr1); i++ {
        arr1[i] = i
    }
    fmt.Println(arr1)

    arr1 = append(arr1, 5, 6, 7, 8, 9, 10)
    fmt.Println("Capacity:", cap(arr1), "Length:", len(arr1))
    fmt.Println(arr1)
}

运行结果如图，可知切片扩容算法是原来容量大小的两倍；在测试代码中发现，如果追加元素超过两倍容量，后面扩容算法就不会是倍数扩容了

4）、copy函数，复制切片中元素

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3, 4, 5, 6}
    slice2 := make([]int, 5, 10)
    copy(slice2, slice1)
    fmt.Println(slice1)
    fmt.Println(slice2)
}

运行结果如下，slice2长度为5，所以只拷贝了slice1的前五个元素

5）、小总结一下，使用 := 方式定义切片，和数组区别仅仅是方括号[]中是否有数字或 ...

示例如下，输出结果都是：[1 2 3 4]

package main

import "fmt"

func main() {
    arr1 := [4]int{1, 2, 3, 4}
    fmt.Println(arr1)
    arr2 := [...]int{1, 2, 3, 4}
    fmt.Println(arr2)
    arr3 := []int{1, 2, 3, 4}
    fmt.Println(arr3)
}

3、字典（Map）

 字典是一组无序的，键值对的集合，字典也叫关联数组，数组通过索引取数，字典通过键来取数

1）、初始化数据方式定义字典

package main

import "fmt"

func main() {
    var x = map[string]string{
        "A": "Apple",
        "B": "Banana",
        "O": "Orange",
        "P": "Pear",
    }

    for key, val := range x {
        fmt.Println("Key:", key, "Value:", val)
    }
}

运行结果

 2）、make函数定义map，如果只定义，不初始化，使用会报错

package main

import "fmt"

func main() {
    var x map[string]string  //定义map
    x = make(map[string]string)  //初始化map

    x["A"] = "Apple"
    x["B"] = "Banana"
    x["O"] = "Orange"
    x["P"] = "Peer"

    for key, val := range x {
        fmt.Println("Key:", key, "Value:", val)
    }
}

3）、使用 := 定义并初始化map

package main

import "fmt"

func main() {
    x := make(map[string]string)

    x["A"] = "Apple"
    x["B"] = "Banana"
    x["O"] = "Orange"
    x["P"] = "Peer"

    for key, val := range x {
        fmt.Println("Key:", key, "Value:", val)
    }
}

4）、获取字典中不存在的key值，如果是整数则返回0，字符串返回 ""；这样的返回值，如果map中就是有值为0或空字符串，就无法区分了

使用 := 可以获取map中元素值和是否存在的布尔类型，如下

package main

import "fmt"

func main() {
    x := make(map[string]int)

    x["A"] = 0
    x["B"] = 1

    val1, ok1 := x["C"]
    fmt.Println(val1)
    fmt.Println(ok1)

    val2, ok2 := x["A"]
    fmt.Println(val2)
    fmt.Println(ok2)
}

运行结果

在实际使用中，可以如下判断是否含有key值

package main

import "fmt"

func main() {
    x := make(map[string]int)

    x["A"] = 0
    x["B"] = 1

    if val, ok := x["C"]; ok {
        fmt.Println(val)
    }else{
        fmt.Println("不存在")
    }
}

输出如下

5）、map中使用delete函数删除元素，如果不存在，删除也不会报错，不会有任何其他影响

package main

import "fmt"

func main() {
    x := make(map[string]int)

    x["A"] = 0
    x["B"] = 1

    fmt.Println("Before Delete:")
    fmt.Println("Length:", len(x))
    fmt.Println(x)

    delete(x, "A")

    fmt.Println("After Delete:")
    fmt.Println("Length:", len(x))
    fmt.Println(x)
}

运行结果

6）、map复杂案例一：

package main

import "fmt"

func main() {
    var facebook = make(map[string]map[string]int)

    //注意下面对map赋值，不要对{}回车换行
    facebook["2018001"] = map[string]int{"Jemy": 25}
    facebook["2018002"] = map[string]int{"Andy": 23}
    facebook["2018003"] = map[string]int{"Bill": 22}

    for stu_no, stu_info := range facebook {
        fmt.Println("Student:", stu_no)
        for name, age := range stu_info {
            fmt.Println("Name:", name, "Age:", age)
        }
        fmt.Println()
    }
}

输出结果

map复杂案例二（执行结果和上面一样）

package main

import "fmt"

func main() {
    var facebook = map[string]map[string]int{
        "2018001": {"Jemy": 25},
        "2018002": {"Andy": 23},
        "2018003": {"Bill": 22},
    }

    for stu_no, stu_info := range facebook {
        fmt.Println("Student:", stu_no)
        for name, age := range stu_info {
            fmt.Println("Name:", name, "Age:", age)
        }
        fmt.Println()
    }
}

 

标签：
来源： https://www.cnblogs.com/hujiapeng/p/9616116.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。