切片类型、

一、切片类型

切片类型:是由数组建立的一种方便灵活的且功能强大的包装,切片本身不拥有任何数据类型,他只是对现有数组的引用。

即:指向了一个地址,本身不拥有数据。

package main

import "fmt"

func main() {
    //切片定义的第一种方式,由数组切出来
    //var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    ////只是对数组的引用
    //var b []int=a[2:6]
    //fmt.Println(b)
    //a[2]=30
    //fmt.Println(b)
    //b[1]=40
    //fmt.Println(b)
    //fmt.Println(a)
    ////原数组的修改会影响切片
    ////切片的修改也会影响底层数组
    //a[1]=20
    //fmt.Println(b)
    //更多用法,没有步长
    //var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    //b:=a[:4]
    //fmt.Println(b)
    //第二种方式,直接定义
    //切片空值是?nil类型
    //var a []int
    //if a==nil{
    //    fmt.Println("我是空的")
    //}
    //a[0]=10
    //fmt.Println(a)
    //定义并初始化,第一个参数是类型,第二个参数是切片的长度,第三个参数是底层数组长度,也就是切片的容量
    //var a []int=make([]int,3)
    //fmt.Println(a)
    //切片的长度和容量(len     cap:容量)
    //切片的长度就是它所包含的元素个数。
    //切片的容量是从它的第一个元素开始数,到其底层数组元素末尾的个数。
    //var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    //var b []int=a[2:6]
    //fmt.Println(len(b))
    //fmt.Println(cap(b))
    //var a []int=make([]int,3,4)
    //fmt.Println(a)
    //fmt.Println(len(a))
    //fmt.Println(cap(a))

    //切片追加值(即给切片赋值)
    //var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    //var b []int=a[2:6]
    //fmt.Println(len(b))  //4
    //fmt.Println(cap(b))  //6
    ////内置函数append,append函数的返回值也为切片
    //b=append(b,555)
    //b=append(b,666)
    //追加两个值之后,容量为6,长度为6
    //底层数组a的相应位置数据也被修改了
    //fmt.Println(b)
    //fmt.Println(len(b))
    //fmt.Println(cap(b))
    //b[0]=999
    //fmt.Println(a)  //a[2]变为999
    //容量满了再继续追加
    //b=append(b,777)
    //fmt.Println(b)
    //长度为7
    //fmt.Println(len(b))
    //切片容量翻倍为12
    //fmt.Println(cap(b))
    //当切片超出底层数组长度时,再进行追加会重新创建一个数组,修改切片中的值不会影响原数组中的值
    //b[0]=999
    //fmt.Println(b)
    //fmt.Println(a)
    //var b =make([]int,3,4)
    //fmt.Println(b)  //[0,0,0]
    //b=append(b,4)
    //fmt.Println(b)  //[0,0,0,4]
    //fmt.Println(len(b))  //4
    //fmt.Println(cap(b))  //4
    //b=append(b,5)
    //fmt.Println(len(b))  //5
    //fmt.Println(cap(b))  //8
    //切片的修改
    //var b =make([]int,3,4)
    //b[0]=999
    //fmt.Println(b)
    //var b =make([]int,4,4)
    //fmt.Println(len(b))
    //fmt.Println(cap(b))
    //切片的函数传递
    //var b =make([]int,3,4)
    //test(b)
    //在函数中修改之后原b切片的值也会改变,即切片是引用传递
    //fmt.Println(b)
    //切片的数据结构表示
    //type slice struct {
    //    Length        int
    //    Capacity      int
    //    ZerothElement *byte
    //}
    //多维切片
    //var a [][]string=make([][]string,2,3)
    //fmt.Println(a[0])  //[]为空切片,只初始化了外层切片
    //a[0]=make([]string,2,3)  //为内层切片初始化
    //if a[0]==nil{
    //    fmt.Println("xxxx")
    //}
    //切片初始化的方法
    //var a []int=[]int{1,2,3}
    //fmt.Println(a)
    //fmt.Println(len(a))
    //fmt.Println(cap(a))
    //多维切片初始化
    //var a [][]string=[][]string{{"1","2"},{"3","4"}}
    //fmt.Println(a)
    //fmt.Println(len(a))
    //fmt.Println(cap(a))
    //a[0][1]="999"
    //fmt.Println(a)
    //a[1][0]="999"
    //var a []int=[]int{1,2}
    //fmt.Println(a)
    //a=append(a,3)
    //fmt.Println(len(a))
    //fmt.Println(cap(a))
    //a[2]=99
    //a[3]=888
    //fmt.Println(a)
    //copy函数
    var a =make([]int,3,10000)
    //底层数组很大,耗费内存
    a[1]=99
    a[2]=888
    fmt.Println(a)

    //var b =make([]int,4,4)
    var b =make([]int,2,4)
    fmt.Println(b)
    //将a copy 到另一个切片上去
    copy(b,a)
    fmt.Println(b)
}

func test(b []int)  {
    b[0]=999
    fmt.Println(b)
}
切片

可变长参数:

package main
//可变长参数
import "fmt"

//可变长参数

func main() {
    //var a =[]int{1,2,4,}
    //test1(1,2,3,4)
    //相当于打散了
    //test1(a...)
    //veggies := []string{"potatoes", "tomatoes", "brinjal"}
    //fruits := []string{"oranges", "apples"}
    //food := append(veggies, fruits...)
    //fmt.Println("food:",food)

    //循环多维切片
    pls := [][]string {
        {"C", "C++"},
        {"JavaScript"},
        {"Go", "Rust"},
    }
    fmt.Println(pls)
    for _,v:=range pls {
        for _,v1:=range v{
            fmt.Println(v1)
        }
    }

}

func test1(a ...int)  {
    fmt.Println(a)
    fmt.Printf("%T",a)

}
可变长参数

二、map

map:在Go中将键(key)值(value)关联起来的内置类型,通过相应的键来获取相应的值。

//maps
package main

import "fmt"

func main() {
    //maps的定义
    //map的key值必须可hash

    //var a map[键值类型]value值类型
    //map的空值是nil类型
    //也是引用类型,在函数中修改原来的值也会被修改
    //var a map[int]string
    //fmt.Println(a)
    //if a==nil{
    //    fmt.Println("xxxx")
    //}
    //map的赋值跟取值
    //map的初始化
    //var a map[int]string=make(map[int]string)
    //fmt.Println(a)
    ////if a==nil{
    ////    fmt.Println("xxxxx")
    ////}
    //a[1]="100"
    //a[2]="888"
    //fmt.Println(a)
    //fmt.Println(a[1])
    ////取一个不存在的key值会?返回value值的空值的默认值(int为0,string为“”)
    ////fmt.Println(a[9])
    //var b map[int]int=make(map[int]int)
    //b[1]=100
    //fmt.Println(b)
    ////fmt.Println(b[9])
    //if v,ok:=a[9];ok{
    //    fmt.Println("=-====",v)
    //}else {
    //    fmt.Println("该值不存在")
    //}
    //v,ok:=a[1]
    //fmt.Println(v)
    //fmt.Println(ok)
    //定义和初始化的第二种方式
    //var a =map[int]string{1:"10",2:"100"}
    ////a[1]
    //fmt.Println(a[1])
    //字典删除元素,内置函数
    //var a =map[int]string{1:"10",2:"100"}
    ////delete(a,2)
    //delete(a,3)
    //fmt.Println(a)

    //map长度
    //var a =map[int]string{1:"10",2:"100"}
    //delete(a,1)
    //a[10]="999"
    //fmt.Println(len(a))
    //Map 是引用类型

    //var a =map[int]string{1:"10",2:"100"}
    //test4(a)
    //fmt.Println(a)
    //Map 的相等性

    //map1 := map[string]int{
    //    "one": 1,
    //    "two": 2,
    //}
    //
    //map2 := map1

    //if map1 == map2 {  //报错
    //}

    //map循环出所有元素
    ////map是无序的
    //for k,v:=range a{
    //    fmt.Println(k)
    //    fmt.Println(v)
    //}



    //补充:切片删除元素
    //var a =[]int{1,2,3,4,5,6}
    //a=append(a[0:2],a[3:]...)
    //fmt.Println(a)

}

func test4(a map[int]string)  {
    a[1]="888"
    fmt.Println(a)

}

//把map做成有序作业
map

三、字符串

字符串:

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {

    //name := "Hello World刘清政"
    //name:=""
    //字符串长度,len统计字节数
    //在go中string类型都是utf-8编码
    //fmt.Println(len(name))
    //fmt.Println(utf8.RuneCountInString(name))
    //unicode是一个字符编码对照表
    //循环
    //字符串是个只读切片
    //name := "name刘"
    //循环的是字节
    //for i:=0;i<len(name);i++{
    //    fmt.Println(string(name[i]))
    //    fmt.Printf("%T",name[i])
    //    fmt.Println()
    //}

    //循环的是字符
    //for _,v:=range name{
    //    fmt.Println(string(v))
    //    fmt.Printf("%T",v)
    //    fmt.Println()
    //}

    //name := "name刘"
    //name[0]=99
    //fmt.Println(name[0])
    //fmt.Println(string(name[0]))

    byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}
    str := string(byteSlice)
    a:=len(str)  //字节数
    b:=utf8.RuneCountInString(str)  //字符数
    fmt.Println(b)
    fmt.Println(a)
    fmt.Println(str)

}
字符串

猜你喜欢

转载自www.cnblogs.com/yangjiaoshou/p/12026231.html