• 数据库
  • Mysql
  • Nosql
  • 技术框架
  • Spring
  • Kafka
  • ibatis
  • 分布式
  • Linux
  • 关于我们
  • 注册
  • 登录
  • Go-数组,切片,map

    2022-10-3 diaba 基础

    一、Array(数组)

    数组是具有相同数据类型的元素组成的一组长度固定的序列,数组的长度不可变化,数组元素是可修改的。

    1.1、声明

    数组声明需要指定组成元素的类型以及元素的个数(长度),长度是数组类型的一部分,数组被声明后,数组长度不可修改,数组元素会根据对应类型的零值进行初始化。

    var name [4]string var age [3]int fmt.Println(name) // [   ] fmt.Println(name) // [0 0 0] 

    1.2、字面量

    在声明时初始化值

    var name [3]string = [3]string{"alex", "eric", "kk"}
    fmt.Println(name) //[alex eric kk] 

    使用初始化元素数量推导数组长度

    name := [...]string{"alex", "eric", "kk"}
    fmt.Println(len(name)) //3 

    指定位置初始化

    name := [10]string{0: "alex", 3: "eric", 6: "kk"}
    fmt.Println(name) //[alex   eric   kk   ] 

    1.3、关系运算符

    关系运算符==!=,只能比较长度与类型一致的数组

    a1 := [2]int{11, 22}
    a2 := [2]int{22, 33} 
    

    fmt.Println(a1 == a2) //false fmt.Println(a1 != a2) //true

    1.4、获取数组长度

    获取数组长度可以使用len函数

    name := [...]string{"alex", "eric", "kk"}
    fmt.Println(len(name)) //3 

    1.5、访问与修改

    数组的访问与修改使用索引,索引从0开始,到数组长度-1为止

    name := [10]string{0: "alex", 3: "eric", 6: "kk"}
    fmt.Println(name[0],name[len(name)-1]) //alex  name[0] = "new" name[len(name)-1] = "alex" fmt.Println(name[0], name[len(name)-1]) //new alex 

    1.6、切片

    获取数组的一部分作为切片

    array[start:end]/array[start:end:cap](end<=cap<=len)
    
    a1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    a2 := a1[1:6]
    fmt.Printf("%T, %v\n", a2, a2) //[]int, [2 3 4 5 6] a3 := a1[1:3:3]
    fmt.Printf("%T, %v\n", a3, a3) //[]int, [2 3] 

    1.7、遍历

    遍历数组可以使用for+len函数和for range两种方法

    a1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} for i := 0; i < len(a1); i++ {
    	fmt.Printf("%d : %v\n", i, a1[i])
    } for i, v := range a1 {
    	fmt.Printf("%d : %v\n", i, v)
    } 

    二、多维数组

    多维数组就是数组中的元素也是数组

    2.1、声明与初始化

    多维数组的声明与初始化与数组基本一致,使用初始化元素数量推导数组长度只有第一维数组可使用

    a1 := [...][3]int{{1, 2, 3}, {2, 3, 4}}
    fmt.Println(len(a1)) 

    2.2、访问与修改

    a1 := [...][3]int{{1, 2, 3}, {2, 3, 4}}
    fmt.Println(a1[1][1]) //3 a1[1][1] = 33 fmt.Println(a1[1][1]) //33 

    2.3、遍历

    for i := 0; i < len(a1); i++ { for j := 0; j < len(a1[i]); j++ {
    		fmt.Printf("[%d %d]: %v\n", i, j, a1[i][j])
    	}
    } for i, line := range a1 { for j, v := range line {
    		fmt.Printf("[%d %d]: %v\n", i, j, v)
    	}
    } 

    三、Slice(切片)

    切片(Slice)是一个拥有相同类型元素的可变长度的序列,是长度可变的数组,切片由三部分组成

    指针:指向切片第一个元素指向的数组元素的地址

    长度:切片元素的数量

    容量:切片开始第一个元素到结束位置元素(底层数组元素末尾)的数量

    3.1、声明

    切片声明需要指定组成元素的类型,但不需要指定存储元素的数量(长度)。在切片声明后,会被初始化为nil,表示暂不存在的切片

    var names []string var ages []int 

    3.2、初始化

    使用字面量初始化

    var names []string{"alex","eric","kk"} 

    使用字面量初始化空切片

    stu1 := []string{} 

    指定长度和容量字面量初始化

    stu2 := []string{0: "alex", 4: "eric"} 

    使用make函数初始化

    stu3 := make([]string, 3) //通过make函数创建长度为3的切片 stu4 := make([]string, 2, 5) //通过make函数创建长度为2,容量为5的切片,长度必须小于等于容量 

    使用数组切片操作初始化

    stu := [5]string{"zhangsan", "lisi", "wangwu", "zhaoliu", "peiqi"}
    stu5 := stu[1:3] //array[start:end] stu6 := stu[1:2:3] //array[start:end:cap](end<=cap<=len) 

    3.3、操作

    获取切片长度和容量

    num := make([]int, 4, 5)
    fmt.Println(len(num), cap(num)) 

    通过对编号对切片元素进行访问和修改,元素的编号从左到右依次为:0, 1, 2, …, n(n为切片长度-1)

    num = []int{1, 2, 3, 4}
    num[0] = 11 fmt.Println(num[0], num[len(num)-1]) 

    切片创建新的切片,切片结束位置小于原切片容量,新创建切片长度和容量计算:len: end-start, cap: src_cap-start,

    num1 := num[:] 
    num2 := num[0:2:3] //slice[start:end:cap]可用于限制新切片的容量值, end<=cap<= src_cap fmt.Println(num1, num2) //[11 2 3 4] [11 2] 

    切片共享底层数组,若某个切片元素发生变化,则数组和其他有共享元素的切片也会发生变化

    num[0] = 111 fmt.Println(num1, num2) //[111 2 3 4] [111 2] 

    遍历,同数组一致

    a1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} for i := 0; i < len(a1); i++ {
    	fmt.Printf("%d : %v\n", i, a1[i])
    } for i, v := range a1 {
    	fmt.Printf("%d : %v\n", i, v)
    } 

    切片复制:复制元素数量为 src元素数量和 dest元素数量的最小值

    a1 := []int{1, 2, 3}
    a2 := []int{10, 20, 30, 40, 50, 60}
    a3 := []int{100, 200, 300, 400, 500, 600, 700, 800, 900} copy(a1, a2)
    fmt.Println(a1, a2) //[10 20 30] [10 20 30 40 50 60] copy(a3, a2)
    fmt.Println(a3, a2) //[10 20 30 40 50 60 700 800 900] [10 20 30 40 50 60] 

    3.4、使用

    新增元素

    使用 append对切片增加一个或多个元素并返回修改后切片,当长度在容量范围内时只增加长度,容量和底层数组不变。当长度超过容量范围则会创建一个新的底层数组并对容量进行智能运算(元素数量<1024时,约按原容量 1倍增加,>1024时约按原容量 0.25倍增加)

     a1 := []int{1, 2, 3}
    a1 = append(a1, 4, 5)
    fmt.Printf("%d,%d,%v\n", len(a1), cap(a1), a1) //5,6,[1 2 3 4 5] a2 := a1[:]
    a2 = append(a2, 6, 7, 8, 9)
    fmt.Printf("%d,%d,%v\n", len(a2), cap(a2), a2) //9,12,[1 2 3 4 5 6 7 8 9] 

    移除元素

    a1 := []int{1, 2, 3, 4, 5, 6} copy(a1[3:], a1[4:])
    fmt.Println(a1) //[1 2 3 5 6 6] fmt.Println(a1[:len(a1)-1]) //[1 2 3 5 6] 

    3.5、队列

    先进先出

    queue := []int{1, 2, 3}
    fmt.Println(queue[0])
    queue = queue[1:]
    fmt.Println(queue[0])
    queue = queue[1:]
    fmt.Println(queue[0]) 

    3.6、堆栈

    先进后出

    stack := []int{1, 2, 3}
    fmt.Println(stack[len(stack)-1])
    stack = stack[:len(stack)-1]
    fmt.Println(stack[len(stack)-1])
    stack = stack[:len(stack)-1]
    fmt.Println(stack[len(stack)-1]) 

    四、多维切片

    切片的元素也是切片,就是多维切片

    4.1、声明和初始化

    num := [][]int{{1, 2, 3}, {4, 5, 6}} 

    4.2、修改

    num[0][1] = 22 fmt.Println(num) //[[1 22 3] [4 5 6]] 

    4.3、切片

    num1 := num[0:1]
    fmt.Println(num1) 

    4.4、遍历

    for i := 0; i < len(num); i++ { for j := 0; j < len(num[i]); j++ {
    		fmt.Printf("[%d %d]: %v\n", i, j, num[i][j])
    	}
    } for i, line := range num { for j, v := range line {
    		fmt.Printf("[%d %d]: %v\n", i, j, v)
    	}
    } 

    4.5、新增元素

    num = append(num, []int{7, 8, 9})
    num[0] = append(num[0], 10)
    fmt.Println(num) //[[1 2 3 10] [4 5 6] [7 8 9]] 

    4.6、切片复制

    num := [][]int{{1, 2, 3}, {4, 5, 6}}
    num1 := [][]int{{}, {}} copy(num1, num)
    fmt.Println(num1) //[[1 2 3] [4 5 6]] 

    五、map(映射)

    映射是存储一系列无序的 key/value对,通过 key来对 value进行操作(增、删、改、查)。

    映射的 key只能为可使用==运算符的值类型(字符串、数字、布尔、数组),value可以为任意类型。

    5.1、声明

    map声明需要指定组成元素key和value的类型,在声明后,会被初始化为nil,表示暂不存在的映射

    var metrics map[string]int var coordinate map[[2]float64]string 

    5.2、初始化

    使用字面量初始化

    metrics := map[string]int{"up_time": 20}
    coordinate := map[[2]float64]string{{11022.11, 122321.00}: "shanghai"}
    fmt.Println(metrics, coordinate) 

    使用字面量初始化空映射

    scores := map[string]int{}
    fmt.Println(scores) 

    使用make函数初始化

    points := make(map[string]int)
    fmt.Println(points) 

    5.3、操作

    获取元素数量

    metrics := map[string]int{"up_time": 20}
    coordinate := map[[2]float64]string{{11022.11, 122321.00}: "shanghai"}
    fmt.Println(len(metrics), len(coordinate)) 

    访问

    //当访问key存在与映射时则返回对应的值,否则返回值类型的零值 fmt.Println(metrics["up_time"]) //20 fmt.Println(metrics["systemd_unit_state"]) //0 

    判断key是否存在

    //通过key访问元素时可接收两个值,第一个值为value,第二个值为bool类型表示元素是否存在,若存在为true,否则为false ret, ok := metrics["up_time"]
    fmt.Println(ret, ok) // 20 true 

    修改与增加

    使用 key对映射赋值时当 key存在则修改 key对应的 value,若 key不存在则增加 key和value

    metrics["up_time"] = 30 metrics["systemd_unit_state"] = 1 fmt.Println(metrics) //map[systemd_unit_state:1 up_time:30] 

    删除

    delete(metrics, "systemd_unit_state")
    fmt.Println(metrics) //map[up_time:30] 

    遍历

    for k, v := range metrics {
    	fmt.Printf("%v,%v\n", k, v)
    }

    标签: go基础

    发表评论:

  • 最新文章

  • Go-数组,切片,map
  • scp拷贝文件
  • 笔试题-牛羊吃草问题
  • 笔试题-最少的袋子数装苹果
  • 递归DP-找零钱的方法数
  • 存档

  • 2022年10月(1)
  • 2022年8月(1)
  • 2022年6月(11)
  • 2022年5月(6)
  • 2022年4月(33)
  • 2022年3月(26)
  • 2021年3月(1)
  • 2020年9月(2)
  • 2018年8月(1)
  • 2018年3月(1)
  • 2017年3月(3)
  • 2017年2月(6)
  • 2016年12月(3)
  • 2016年11月(2)
  • 2016年10月(1)
  • 2016年9月(3)
  • 2016年8月(4)
  • 2016年7月(3)
  • 2016年6月(4)
  • 2016年5月(7)
  • 2016年4月(9)
  • 2016年3月(4)
  • 2016年2月(5)
  • 2016年1月(17)
  • 2015年12月(15)
  • 2015年11月(12)
  • 2015年10月(6)
  • 2015年9月(11)
  • 2015年8月(8)
  • 分类

  • Java(4)
  • 基础(8)
  • IO(3)
  • JVM(7)
  • 多线程(11)
  • 调优命令(1)
  • Go(0)
  • 基础(1)
  • Linux(10)
  • mac(12)
  • 数据库(2)
  • Mysql(7)
  • Nosql(8)
  • 技术框架(2)
  • Spring(5)
  • Kafka(3)
  • ibatis(2)
  • 分布式(4)
  • 数据结构与欧宝安德拉(0)
  • 数据结构(6)
  • 欧宝安德拉(44)
  • 笔试题(19)
  • emlog(1)
  • 问题解决记录(2)
  • 随笔记录(26)
  • 金融(1)
  • 工具使用(8)
  • 操作系统(3)
  • 用友NC(3)
  • NC常见问题(2)
  • 热门文章

  • SpringMVC:Null ModelAndView returned to DispatcherServlet with name 'applicationContext': assuming HandlerAdapter completed request handling
  • Mac-删除卸载GlobalProtect
  • java.lang.SecurityException: JCE cannot authenticate the provider BC
  • Idea之支持lombok编译
  • MyBatis-Improper inline parameter map format. Should be: #{propName,attr1=val1,attr2=val2}
  • 标签

    mac emlog NC授权 授权数 用户数 破解 天上一天 redis 已达授权数 用友NC 可打印 地上一年 超光速 大于光速 时间静止 时光倒流 相对论 go基础 shell CountDownLatch 狱中诗 线程同步 任务同步 SecureCRT 光标消失 做人 做事 职业发展 选人 转义字符 json 格式错误 内存分区 操作系统 cache 分布式 程序 Linux crontab 定时任务 license 安全 备份 IO操作 同步 异步 阻塞 进程 线程 并发 共享内存 mybatis Improper inline 数据库 mysql 如果为null query paxos 分布式一致性 if ifnull spring ioc BlockingQueue OOM 软引用 弱引用 并行 jvm参数 gc jvm kafka 2016 数据库引擎 加密 解密 java文件压缩 命令 RDB AOF 配置 调优 sharding jvm结构 存储引擎 myiasm innodb 乐观锁 悲观锁 理财 欧宝安德拉 异地多活 ctrl+alt+delete idea lombok springmvc aes 宝宝 项目经理 nc curl 按位操作 逻辑思维 excel 原子增操作 awk printf OceanBase mac锁屏 快捷键 文件监听 confict git 商品管理 sku 自动注入 Apple ID Javassist branch 正则表达式 参数必填 代码优化 grep 程序员 未来 保险 坦然生活 抗风险 优秀经纪人 汉诺塔 递归
  • 最新评论

  • logisqykyk
    Javassist分析、编辑和创建jav...
  • xxedgtb
    Redis—常见参数配置 - 韭菜园 ...
  • wdgpjxydo
    SpringMVC:Null Model...
  • rllzzwocp
    Mysql存储引擎MyISAM和Inno...
  • dpkgmbfjh
    SpringMVC:Null Model...
  • tzklbzpj
    SpringMVC:Null Model...
  • bqwrhszmo
    MyBatis-Improper inl...
  • 乐谱吧
    good非常好
  • diaba
    @diaba:应该说是“时间的度量依据”...
  • diaba
    如果速度增加接近光速、等于光速、甚至大于...
  • 最新微语

  • 从今天起,做一个幸福的人。喂马,砍柴,(思想)周游世界

    2022-03-21 23:31

  • 2022.03.02 23:37:59

    2022-03-02 23:38

  • 几近崩溃后,找到解决方法,总是那么豁然开朗!所以遇到问题要坚持!

    2018-07-18 10:49

  • 2018年关键字“走心”

    2018-03-19 16:07

  • 保护好自己最大的方法是让自己更强大,不要柔弱的像一只绵羊一样,得谁巴拉,就谁巴拉!

    2017-12-20 10:24

  • 更多»

    Powered by emlog 京ICP备15045175号-1 Copyright © 2022