数组和切片和Map

已于 2022-09-03 23:07:46 修改
阅读量325 收藏
点赞数
分类专栏： Go 文章标签： golang
于 2022-08-31 15:03:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53089304/article/details/126619276
版权

集合

1，数组

声明数组
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

初始化数组

//第一种方式
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

//第二种方式
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

 balance[4] = 50.0

以上实例读取了第五个元素。数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。
在这里插入图片描述

访问数组元素
数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。例如：

var salary float32 = balance[9]

以上实例读取了数组 balance 第 10 个元素的值。
以下演示了数组完整操作（声明、赋值、访问）的实例：

package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */        
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

package main

import "fmt"

func main() {
   var i,j,k int
   // 声明数组的同时快速初始化数组
   balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

   /* 输出数组元素 */         ...
   for i = 0; i < 5; i++ {
      fmt.Printf("balance[%d] = %f\n", i, balance[i] )
   }
   
   balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
   /* 输出每个数组元素的值 */
   for j = 0; j < 5; j++ {
      fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
   }

   //  将索引为 1 和 3 的元素初始化
   balance3 := [5]float32{1:2.0,3:7.0}  
   for k = 0; k < 5; k++ {
      fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
   }
}

2，切片

Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片
1，第一种方式
在这里插入图片描述
2，第二种方式
在这里插入图片描述
3，第三种方式
在这里插入图片描述
遍历切片
1，第一种方式
在这里插入图片描述
2，第二种方式
在这里插入图片描述
注意事项与细节
切片初始化时(取的是[startIndex,endIndex))

var slice = arr[startIndex:endIndex]

简写

//第一种
var slice = arr[:end]//var slice = arr[0:end]
//第二种
var slice = arr[start:]//var slice = arr[start:len(arr)]
//第三种
var slice = arr[:]//var slice = arr[0:len(arr)]

cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用。

空切片
一个切片在未初始化之前默认为 nil，长度为 0，实例如下：

package main

import "fmt"

func printSlice(x []int){
	fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
func main(){
	var numbers []int
	printSlice(numbers)
	if numbers == nil {
		fmt.Println("切片是空的")
	}
}
/*
输出结果：
len=0 cap=0 slice=[]
切片是空的
*/

扩容和复制

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)  
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

3，Map

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
定义Map
可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

在这里插入图片描述
map的使用

  • 方式一
    在这里插入图片描述
  • 方式二
    在这里插入图片描述
  • 方式三
    在这里插入图片描述
    map遍历
package main

import "fmt"

func main() {
	cities := make(map[string]string)
	cities["no1"] = "北京"
	cities["no2"] = "天津"
	cities["no3"] = "上海"
	for k,v := range cities {
		fmt.Printf("key=%v value=%v ",k,v)
	}
	fmt.Println()
	studentMap := make(map[string]map[string]string)
	studentMap["stu01"] = make(map[string]string, 3)
	studentMap["stu01"]["name"] = "tom"
	studentMap["stu01"]["sex"] = "男"
	studentMap["stu01"]["address"] = "上海"

	studentMap["stu02"] = make(map[string]string, 3)
	studentMap["stu02"]["name"] = "jack"
	studentMap["stu02"]["sex"] = "女"
	studentMap["stu02"]["address"] = "东莞"

	for k1,v1 := range studentMap {
		fmt.Println("k1=",k1)
		for k2,v2 := range v1 {
			fmt.Printf("\t k2=%v v2=%v\n",k2,v2)
		}
		fmt.Println()
	}
}

使用案例
在这里插入图片描述
删除
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：
在这里插入图片描述
map排序

  1. golang 中没有一个专门的方法针对map 的key进行排序

  2. golang 中的map默认是无序的，注意也不是按照添加的顺序存放的，你每次遍历，得到的输出可能不一样.

  3. golang 中 map的排序，是先将key进行排序，然后根据key 值遍历输出即可

package main

import (
	"fmt"
	"sort"
)

func main() {
	map1 := make(map[int]int, 10)
	map1[9] = 90
	map1[1] = 10
	map1[2] = 20
	map1[3] = 30
	map1[4] = 40
	var number []int
	for index, _ := range map1 {
		number = append(number,index)
	}
	sort.Ints(number)
	fmt.Println(number)
	for _, k := range number {
		fmt.Printf("map1[%v]=%v\n",k,map1[k])
	}
}

map的使用细节

  1. map是引用类型，遵守引用类型传递的机制，在一个函数接收map，修改后，会直接修改原来的map
    在这里插入图片描述
  2. map 的容量达到后，再想map增加元素，会自动扩容，并不会发生panic，也就是说map能动态的增长键值对(key-value)

3.map的value也经常使用struct类型，更适合管理复杂的数据(比前面value是一个map更好)，比如 value为Student 结构体
在这里插入图片描述

4，切片和string之间的区别

（1）string底层是一个byte数组，因此string也可以进行切片处理 案例处理：
在这里插入图片描述
（2）string是不可变的，也就说不能通过str[0] = 'z’方式来修改字符串
在这里插入图片描述
（3）如果需要修改字符串，可以先将string->[]byte或者[]rune，接着重转成string
在这里插入图片描述

5，二维数组

使用方式
（1）先声明or定义，再赋值
在这里插入图片描述
（2）直接初始化
在这里插入图片描述
在这里插入图片描述

package main

import "fmt"

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

二维数组的遍历

  • 双层for循环完成遍历
  • for-range完成遍历
package main

import "fmt"

func main() {
	var arr1 [2][2]int = [2][2]int{{1,2},{3,4}}
	for i := 0; i < len(arr1); i++ {
		for j := 0; j < len(arr1[i]); j++ {
			fmt.Printf("值为%v ",arr1[i][j])
		}
	}

	for i,v := range arr1 {
		for j,vv := range v {
			fmt.Printf("值为arr1[%v][%v]=%v\t",i,j,vv)
		}
	}
}

6，map切片

切片的数据类型如果是map，则我们称为 slice of map，map切片，这样使用则map个数就可以动态变化了。

案例

package main

import "fmt"

func main() {
	var monsters []map[string]string
	monsters = make([]map[string]string, 2)
	if monsters[0] == nil {
		monsters[0] = make(map[string]string, 2)
		monsters[0]["name"] = "牛魔王"
		monsters[0]["age"] = "100"
	}

	if monsters[1] == nil {
		monsters[1] = make(map[string]string, 2)
		monsters[1]["name"] = "蛇精"
		monsters[1]["age"] = "100"
	}
	fmt.Println(monsters)
	newMonster := map[string]string {
		"name" : "新妖怪",
		"age" : "100",
	}
	monsters = append(monsters,newMonster)
}
南绘
关注
专栏目录
Java开发基础——数组、List与Map的使用
乞力马扎罗的雪CYF的博客
04-02 3145
在Java中可以定长的来初始化一个数组，并可以使用下标index来赋值或取值，使用非常方便。示例代码如下： Object[] objects = new Object[2]; objects[0] = 100; objects[1] = "chen"; System.out.println("objects:" + objects);
map与数组
qq_42448782的博客
12-20 205
map与数组
06 数组、切片和map
zhangxm_qz的博客
03-06 296
文章目录数组切片String和slice 数组 数组可以存放多个相同类型的数据 数组定义：var 数组名[数组大小] 数据类型 数组元素的访问：数组名[下标] ，下标从0 开始 数组的地址可以通过 数组名来获得 &数组名 数组中各个元素地址间隔是根据数组中数据类型决定的 ，如：int64 ->8 int32->4 注意事项 一旦声明数组长度固定不能动态变化 var arr[] int 这样定义时，其实是定义了一个切片 数组中的元素可以是任何数据类型，但是不能混用 数组创建后如果没有赋值
数组 array_map
shinebxy的博客
10-09 1006
  $data = ['lala','man',12]; $res = ['baibai',19,'girl']; array_map(function($val) use(&amp;$data,&amp;$res){     if($res[0] == $val['name']){         $data[] = $val['sex'];     }   },$arr) $val 就...
数组、Set、Map的区别
qq_37609418的博客
08-19 2431
*总结：**当需要频繁的遍历查找，操作元素时建议使用Map或Set解构，当需要下标时可使用数组。JS的对象(Object)，本质是键值对的集合(Hash)结构，实际上只可以使用字符串当作键。**特点：**成员值唯一，成员有序，顺序存储。[Value,Value]结构。Set和Map都可以使用[…Map的遍历顺序就是插入顺序。Map可以使用任何类型作为键。Map的值通过地址进行对比。都可以用来生成新的Map。
Go进阶(5): 数组与切片+多维数组+map切片
沈春旭的博客
08-18 4993
1. 数组array 数组可以存放多个同一类型数据，数组也是一种数据类型，在Go中，数组是值类型。与C++一致 长度是的固定的，不能够动态变化 var arr [] int 相当于slice切片 var 数组名 [数组大小] 数据类型 eg: var hens[100]float64 heroes := [...]string{"songjiang","lujunyi","wuyong"...
参照Java学Go（三）—— go的内置类型：数组、切片slice、map
mingjia1987的博客
05-29 2924
    前一篇说到了go的变量、常量和基本数据类型，接下来继续说一下go的其他内置类型：数组、切片（slice）和集合（map）    一，数组    go和java中肯定都有数组了，只不过在定定义上和定义变量类似，把类型放到了后边（还是觉得很难受有没有？）    首先对比一下定义：//java： int[] arr; //没有初始化 arr = new int[1]{}; ...
go语言学习--数组、切片、map初始化操作和区别
aiwo035的博客
05-04 2031
Go语言中，数组是一种具有相同类型固定大小的一种数据结构，数组定义会定义长度 数组的声明语法如下： var 数组变量名 [元素数量]Typea:= [3]int{} //我们可以通过如下方式给数组赋值 a[0] = 1 a[1] = 2 a[2] = 3 //数组遍历 for i, v := range a { fmt.Printf("%d %d\n", i, v) } //...
Go语言字符串、数组和切片操作解析
"《数字信号处理》第四版高西全版课后部分习题答案-字符串数组和切片的应用" 本文主要介绍了Go语言中字符串、数组和切片的应用，特别是它们之间的转换和操作方法。在Go语言中，字符串本质上是一个字节数组，可以...
Golang学习系列第三天：学习数组、切片、Map、结构体、指针、函数、接口类型、channel通道
董广明的博客
07-15 1015
继Golang学习系列第二天：变量、常量、数据类型和流程语句之后，今天开始学习数据类型之高级类型： 派生类型。 学过java的人都知道，java其实就8种基本类型：byte、short、int、long、float、double、char、boolean，但它有引用数据类型：字符串、数组、集合、类、接口等。 而golang也有这样的划分，基本类型（Golang学习系列第二天已学过）和派生类型（不叫引用类型），派生类型有以下几种：数组类型、切片类型、Map类型、结构体类型(struct)、指针...
Go语言基础学习(数组、切片、Map)
Aslixzhou
12-19 770
一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。make也是用于内存分配的，区别于new，它只用于slice、map以及channel的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。切片再执行切片表达式时（切片再切片），high的上限边界是切片的容量cap(a)，而不是长度len(a)
Java中的集合
zxjnmc
10-29 590
第一章 集合概述我们知道在集合的框架的继承树中,最顶层有两个接口,分别是Collection和Map.Collection表示一组纯数据,而Map则表示一组键值对Collection是最基本的集合接口,一个Collection代表一组对象,也就是Collection的元素.JDK不提供直接继承自Collection的类,JDK提供的类都是继承自Collection的子接口,比如说List和Set.所
深度解析 List、Map、Set 和数组
最新发布
Kuangtian的博客
12-20 1018
选择合适的数据结构是程序设计中的重要环节。列表、字典、集合和数组各自有着独特的特点和优势，根据具体问题的性质和需求进行选择是至关重要的。深入理解这些数据结构的特性和用法，有助于在编程中更高效地解决问题，提高代码的性能和可读性。在实际应用中，根据数据的特点和操作的要求，选择合适的数据结构是优化程序性能的关键一步。
数组的Map方法详解
热门推荐
wfly blog
12-05 1万+
map()：创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。indexarraymapthisArg： 可选，执行callback函数时值被用作this返回值：一个由原数组每个元素执行回调函数的结果组成的新数组。mapcallbackcallbackundefinedcallbackdeletemapcallback因为map生成一个新数组，当你不打算使用返回的新数组却使用请用forEach或者for-of替代。
Java Map集合与数组有什么区别？
m0_50465418的博客
08-24 471
java中的Map集合与数组不同之处是：Map集合由多个键值对的元素组成的集合，数组由多个元素组成的，该数组不采用键值对的方式保存数组，这就是java中Map集合与数组的不同之处 点击此处了解Java中的Map集合的详细介绍以及使用
Java 中Map与数组的比较
evilcry2012的专栏
09-18 2343
Java 中Map与数组的比较 50 谁占用的空间大，谁的速度更快呢？ 主宰比赛Eddie | 浏览 292 次 |举报 我有更好的答案 发布于2017-02-23 22:57 最佳答案 1、数组特点高效、保存基本类型，集合带array的底层由数组实现，还有一部分由链表或者树2、数组大小固定（巨大缺点，内存中一定连续），集合各种实现吧！3
数组中map()方法的运用
jh_jing的博客
08-30 5066
1、map() 方法返回一个新数组，新数组中的元素为原始数组中的每个元素调用函数处理后得到的值。 2、map() 方法按照原始数组元素顺序依次处理元素。 注意：map() 不会对空数组进行检测。 注意：map() 不会改变原始数组。 注意：函数的作用是对数组中的每一个元素进行处理，返回新的元素。 3、语法 map是数组的方法，有一个参数，参数是一个函数，函数中有3个参数 参数1：item必须。当前元素的值 参数2：index，可选。当前元素在数组中的索引值 参数3：arr可选。当前元素..
Java中具有映射关系的容器：数组和Map的区别
G_66_hero的博客
04-15 2079
映射就意味着有两部分； 存储映射关系的容器是数组和Map集合； 区别： （1）当映射关系中的一方是有序编号时，这个时候要想到数组这种结构； （2）Map不一定需要有序编号，它只能建立对象之间的关系； （3）如果映射的两方没有任何一方是有序的编号，就不能想数组了，这时应该用集合中具备映射关系的容器Map。 注意： (1)Map中键相同时，键值会被覆盖； (2)Map中一个Ke
数组之map方法详解
m0_67402970的博客
08-29 539
【代码】数组之map方法详解。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值