人生苦短我使用GO——GO数组（小demo）

最新推荐文章于 2024-05-01 17:40:59 发布
最新推荐文章于 2024-05-01 17:40:59 发布
阅读量428 收藏
点赞数
分类专栏： GO语言 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48404074/article/details/123832566
版权

目录

GO数组

        声明数组

初始化数组

                练习题：//控制台输入10名学生的成绩，如果低于60分的，自动修正成绩为60，并且展现成绩清单

访问数组元素

                小练习：//输入5个数字，求出最大值

        冒泡排序

        定义不定长数组添加元素

多维数组

                实例初始化一个2行2列的二维数组

                访问 二维数组

                创建各维度数量不一致的元素

向函数传递数组

GO数组

        数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

相对于去声明number0, number1..., number99的变量，
使用数组形式numbers[0],numbers[1]...numbers[99]
更加方便且易于扩展。

数组元素可以通过索引(位置）来读取(或者修改)，索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。

 

        声明数组

        声明需要指定元素类型及元素个数,

        语法格式如下:

var variable_name [SIZE] variable_type

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

var balance [10] float32

初始化数组

var balance =[5]float32{10.0,2.0,5.3,7.0,50.0}

可以通过字面量在声明数组的同时快速初始化数组:

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

demo1

package main
​
import "fmt"
//数组定义元素下标数组长度
var Array =[10]int{1,2,3,4,5,6,7,8,9,10}
​
func main(){
//数组元素提取
// fmt .Println(Array[0])1
// fmt. Print1n(Array[9])//shu
for i := 0; i< 10; i++ {
    fmt.Println(Array[i])
}
​
}
运行结果

1
2
3
4
5
6
7
8
9
10

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

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

或

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

示例

package main
​
import "fmt"
​
var array = [...]int{1, 2, 3, 4, 6, 5, 8}
​
func main() {
​
    for i := 0; i < len(array); i++ {
        fmt.Println("", array[i])
    }
​
    fmt.Println("数组长度为", len(array))
​
}
​
运行结果

 1
 2
 3
 4
 6
 5
 8
数组长度为 7

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

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

示例

package main
​
import "fmt"
​
var Array = [...]int{1: 2, 3: 6, 5: 6}
​
func main() {
    for i := 0; i < len(Array); i++ {
        fmt.Println("数组里面的数字为",Array[i])
    }
}
运行结果

数组里面的数字为 0
数组里面的数字为 2
数组里面的数字为 0
数组里面的数字为 6
数组里面的数字为 0
数组里面的数字为 6

初始化数组中0中的元素个数不能大于0中的数字。

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

balance[4] = 50.0

示例：

package main
​
import "fmt"
​
var Array = [...]int{1: 2, 3: 6, 5: 6}
​
func main() {
    for i := 0; i < len(Array); i++ {
        fmt.Println("数组里面的数字为",Array[i])
    }
​
    Array[4] = 50
    fmt.Println(Array)
}
运行结果

数组里面的数字为 0
数组里面的数字为 2
数组里面的数字为 0
数组里面的数字为 6
数组里面的数字为 0
数组里面的数字为 6
[0 2 0 6 50 6]

                练习题：//控制台输入10名学生的成绩，如果低于60分的，自动修正成绩为60，并且展现成绩清单

package main
​
import (
    "fmt"
)
​
//控制台输入10名学生的成绩，如果低于60分的，自动修正成绩为60，并且展现成绩清单
var Array = [10]int{}
​
func main() {
​
    for i := 0; i < 10; i++ {
        fmt.Printf("请输入%d学生成绩", i+1)
        fmt.Scan(&Array[i])
​
        if Array[i] < 60 {
​
            fmt.Println("望继续努力！")
            Array[i] = 60
        } else {
            fmt.Printf("%d号成绩为:", i+1)
            fmt.Println(Array[i])
        }
    }
​
    for j := 0; j < len(Array); j++ {
        fmt.Printf("%d号学生成绩为:", j+1)
        fmt.Println(Array[j])
    }
}
​

运行结果

go run .\main.go
请输入1学生成绩56
望继续努力！
请输入2学生成绩78
2号成绩为:78
请输入3学生成绩56
望继续努力！
请输入4学生成绩80
4号成绩为:80
请输入5学生成绩35
望继续努力！
请输入6学生成绩67
6号成绩为:67
请输入7学生成绩89
7号成绩为:89
请输入8学生成绩35
望继续努力！
请输入9学生成绩78
9号成绩为:78
请输入10学生成绩90
10号成绩为:90
1号学生成绩为:60
2号学生成绩为:78
3号学生成绩为:60
4号学生成绩为:80
5号学生成绩为:60
6号学生成绩为:67
7号学生成绩为:89
8号学生成绩为:60
9号学生成绩为:78
10号学生成绩为:90

访问数组元素

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

var salary float32 = balance[9]

以上实例读取了数组balance第10个元素的值。

package main
​
import "fmt"
​
func main() {
​
    var i, j, k int
    //声明数组的同时快速初始化数组
​
    balance := [5]float32{1006.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])
​
    }
}
​
​
运行结果

balance[0] = 1006.000000
balance[1] = 2.000000
balance[2] = 3.400000
balance[3] = 7.000000
balance[4] = 50.000000
balance2[0] = 1000.000000
balance2[1] = 2.000000
balance2[2] = 3.400000
balance2[3] = 7.000000
balance2[4] = 50.000000
balance3[0] = 0.000000
balance3[1] = 2.000000
balance3[2] = 0.000000
balance3[3] = 7.000000
balance3[4] = 0.000000

                小练习：//输入5个数字，求出最大值

package main
​
import "fmt"
​
​
func main() {
​
    var (
        a   int //数字
        b   int
        num [5]int //总数
    )
​
    for i := 0; i < 5; i++ {
        fmt.Printf("请输入%d个数字:", i+1)
        fmt.Scan(&a)
        //数字添加到数组当中
        num[i] = a
        
    }
    fmt.Println("数组添加完毕")
    //先给一个值
    b = num[0]
    for j := 0; j < 5; j++ {
        if num[j] > b {
            b = num[j]
        }
    }
    //输出最大值
    fmt.Println("最大值为:", b)
}
​
运行结果

go run .\main.go
请输入1个数字:11
请输入2个数字:22
请输入3个数字:33
请输入4个数字:66
请输入5个数字:33
数组添加完毕
最大值为: 66

        冒泡排序

        冒泡排序法是一种最简单的交换类排序方法，它是通过相邻数据的交换逐步将无序列表排列为有序列表。

        冒泡排序的基本原理是重复地循环遍历要排序的元素列，依次比较两个相邻的元素，如果顺序（如从小到大或者首字母从 Z 到 A）错误就把两个元素的位置交换过来，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

        冒泡排序的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同气泡最终会上浮到顶端一样，故名“冒泡排序”。

可以想象比武招亲 擂台上守擂和攻擂 一一比较

package main
​
import "fmt"
​
func main() {
    var (
        num = [...]int{57, 76, 65, 43, 75, 89, 78}
        t   = len(num)
    )
    fmt.Println("没排序之前:\n", num)
    for i := 0; i < t; i++ {
        fmt.Println("第", i+1, "次冒泡")
        for j := 0; j < t; j++ {
            if num[i] < num[j] {
                sum := num[i]
                num[i] = num[j]
                num[j] = sum
            }
        }
        fmt.Println("排序之后.", num)
​
    }
    fmt.Println("从小到大排序依次为:\n", num)
}
​
运行结果

没排序之前:
 [57 76 65 43 75 89 78]
第 1 次冒泡
排序之后. [89 57 65 43 75 76 78]
第 2 次冒泡
排序之后. [57 89 65 43 75 76 78]
第 3 次冒泡
排序之后. [57 65 89 43 75 76 78]
第 4 次冒泡
排序之后. [43 57 65 89 75 76 78]
第 5 次冒泡
排序之后. [43 57 65 75 89 76 78]
第 6 次冒泡
排序之后. [43 57 65 75 76 89 78]
第 7 次冒泡
排序之后. [43 57 65 75 76 78 89]
从小到大排序依次为:
 [43 57 65 75 76 78 89]

        定义不定长数组添加元素

package main
​
import "fmt"
​
var (
    names []string
    name  string
)
​
func main() {
    for i := 0; i < 5; i++ {
        fmt.Printf("请输入%d的名字:", i+1)
        fmt.Scan(&name)
        names = append(names, name)
        fmt.Print()
​
    }
​
    for j := 0; j < 5; j++ {
        //输入的名字
        fmt.Println(names[j])
    }
​
}
​
运行结果

请输入1的名字:张三
请输入2的名字:李四
请输入3的名字:马武
请输入4的名字:马六
请输入5的名字:李琦
张三
李四
马武
马六
李琦

多维数组

多维数组声明方式:

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

以下实例声明了三维的整型数组:

var threedim [5][10][4]int

二维数组 二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的。二维数组定义方式如下:

var arrayName[× ][y ] variable_type

variable_type为数据类型，arrayName为数组名，二维数组可认为是一个表格，x为行，y为列，下图演示了一个二维数组a为三行四列;

示例

package main
​
import "fmt"
​
//初始化二维数组
var values [][]int
​
func main() {
    //定义一堆一维数组
    var row = [...]int{1, 2, 3}
    var row1 = [...]int{2, 3, 4}
    //将一维数组放入二维数组当中
    values = append(values, row[:])
    values = append(values, row1[:])
    fmt.Println("二维数组第一个元素的值:", values[0])
    fmt.Println("二维数组第二个元素的值:", values[1])
​
    fmt.Println("二维数组中第一个一维数组的第一个元素为:", values[0][0])
}
​
运行结果

二维数组第一个元素的值: [1 2 3]
二维数组第二个元素的值: [2 3 4]
二维数组中第一个一维数组的第一个元素为: 1

                实例初始化一个2行2列的二维数组

package main
​
import "fmt"
​
func main() {
    var nums = [2][2]string{}
​
    nums[0][0] = "java"
    nums[0][1] = "GO"
    nums[1][0] = "PHP"
    nums[1][1] = "C"
    fmt.Println("学科有:", nums)
}
运行结果

学科有: [[java GO] [PHP C]]

                访问 二维数组

二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如:

实例访问了二维数组val第三行的第四个元素。

var := a[2][3]
或
var value int = a[2][3]

二维数组可以使用循环嵌套来输出元素:

package main
​
import "fmt"
​
func main() {
    nums := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    //遍历二维数组的数字
​
    //外层读行
    for i := 0; i < 2; i++ {
        //内存读列
        for j := 0; j < 3; j++ {
            //输出数组中的数字
            fmt.Println(nums[i][j])
        }
    }
}
​
运行结果

1
2
3
4
5
6

示例二

package main
​
import "fmt"
​
func main() {
​
    nums := [5][2]int{
        {2, 3},
        {3, 5},
        {5, 4},
        {3, 3},
        {4, 5},
    }
​
    for i := 0; i < 5; i++ {
        for j := 0; j < 2; j++ {
            fmt.Printf("nums[%d][%d]=%d\n", i, j, nums[i][j])
        }
    }
运行结果

nums[0][0]=2
nums[0][1]=3
nums[1][0]=3
nums[1][1]=5
nums[2][0]=5
nums[2][1]=4
nums[3][0]=3
nums[3][1]=3
nums[4][0]=4
nums[4][1]=5

                创建各维度数量不一致的元素

package main
​
import "fmt"
​
func main() {
    //创建空的二维数组
    nums := [][]string{}
​
    //创建三个一维数组，添加进二维数组
​
    row1 := []string{"张三","李四","王五"}
    row2 := []string{"马六","天琪"}
    row3 := []string{"老六"}
​
    nums = append(nums, row1)
    nums = append(nums, row2)
    nums = append(nums, row3)
​
    //遍历
    for v := range nums {
        fmt.Printf("row:%v\n",v+1)
        fmt.Println(nums[v])
        
    }
    
}
运行结果

row:1
[张三 李四 王五]
row:2
[马六 天琪]
row:3
[老六]
​

向函数传递数组

如果想向函数传递数组参数，需要在函数定义时，声明形参为数组，可以通过以下两种方式来声明:

方式一

形参设定数组大小:

void myFunction(param [10]int)
{
    .
    .
    .
    .
}

方式二 形参未设定数组大小:

void myFunction(param [ ]int)
{
    .
    .
    .
    .
    
}

示例:函数接收整型数组参数，另一个参数指定了数组元素的个数，并返回平均值:

package main
​
import "fmt"
​
//函数接收整型数组参数，另一个参数指定了数组元素的个数，并返回平均值:
var avg float32
​
func main() {
    //定义数组长度
    long := [5]int{1, 5, 5, 3, 2}
​
    //数组作为参数传递给函数
    avg = getAvgre(long, len(long))
​
    //输出
    fmt.Println("平均值为:", avg)
}
​
func getAvgre(arr [5]int, size int) float32 {
​
    var sum int
​
    for v := range arr {
        sum += arr[v]
    }
​
    // for i := 0; i < size; i++ {
​
    //  sum += arr[i]
​
    // }
    avg = float32(sum) / float32(size)
​
    return avg
}
​
运行结果

平均值为: 3.2

小柏ぁ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Go语言开发】简单了解一下搜索引擎并用go写一个demo
面向生活编程
07-14 4550
这篇文章我们一起来了解一下搜索引擎的原理，以及用go写一个小demo来体验一下搜索引擎。
Go语言学习笔记（一）——基础语法与demo开发解析
rippersudo的博客
05-12 973
主要内容：1、go语言基础语法；2、示例代码解析
Go Web 开发 Demo【用户登录、注册、验证】
最新发布
m0_64261982的博客
05-01 1240
Go 语言Web开发基础，GIN 实现用户注册、登录、验证
go数组初始化
qq_31805127的博客
03-14 1436
1、数组初始化： `var ba = [5] float32{1000,2,3,7,50} //或者 balance:=[5]float32{1000,2,3,7,50} 2、如果数组长度不确定，可以使用…代替数组长度。 var ba = [...]float32{1000,2,3,7,50} //或者 balance := [...]float32{1000,2,3,7,50} 3、设置了数组的长度，还可以指定下标来初始化元素，其中初始化数组中{}的元素个数不能大于[]中的数字。 balance :=
[go-web开发小试验] 1-第一个demo程序
一名普通码农的菜地
11-19 727
前言 目前的go似乎值得一试。 参考 参考了网上的go web开发入门 之类的文章。 步骤 在idea上面开一个新项目，然后，嗯。。。我用的是go1.11，有module模块了，然后添加一个文件，内容如下： package src import ( "fmt" "log" "net/http" "strings" ) func sayhelloName(w http.ResponseW...
小程序DEMO——虎扑足球：使用underscore.js与wxParse
03-15
【小程序DEMO——虎扑足球：使用underscore.js与wxParse】是一个展示如何在微信小程序中集成underscore.js库和wxParse组件来实现特定功能的实例。本文将深入探讨这两个技术在小程序开发中的应用。 首先，让我们了解...
小程序DEMO——简易电商
03-15
【小程序DEMO——简易电商】是一个面向初学者和开发者的小型项目，旨在提供一个基础的电商应用模型。这个DEMO涵盖了微信小程序开发的核心技术，帮助理解如何构建一个基本的线上购物平台。通过学习和实践这个项目，你...
小程序DEMO——图片上传demo（附java后端）
03-15
【小程序DEMO——图片上传demo（附java后端）】是一个综合性的项目，涉及到前端小程序开发和后端Java服务的集成。在这个项目中，开发者提供了一个简易的小程序应用示例，该示例主要功能是实现图片的上传。下面将详细...
ListView简单使用实例——新闻页面demo
01-03
使用它可以用来显示我们常见的列表形式，继承自抽象类 AdapterView。 常用适配器介绍 ArrayAdapter：简单、易用的 Adapter，用于将数组数据作为数据源绑定到列表项中。支持泛型操作 SimpleAdapter：相比 ...
笑话大全——微信小程序Demo
03-15
此项目是学习完微信小程序后实现的一个demo，采用聚合数据的免费api获取最新的文本笑话和趣图   免责声明：本站所有文章和图片均来自用户分享和网络收集，文章和图片版权归原作者及原出处所有，仅供学习与参考，...
GO语言如何接入代码 demo？
weixin_44617651的博客
10-12 488
Go语言作为服务器编程的一种语言，非常适合处理数据打包、日志、虚拟机处理、文件系统、数据库等。Go语言能够让程序员快速开发，并且在软件不断的增长过程中，它能让程序员更容易地进行维护和修改。它融合了传统编译型语言的高效性和脚本语言的易用性和富于表达性。urlproxy, _ := urli.Parse(“http://测试:端口”)urlproxy, _ := urli.Parse(“http://测试:端口”)fmt.Println(“本机:”, string(body))//华科http代理。
go 的不定长二维数组初始化
weixin_41975177的博客
08-18 1143
Go 数组和切片
Go 学习笔记（14）— 结构体定义、实例化、初始化、匿名结构体、结构体访问、结构体作为形参、结构体指针
wohu1104的专栏
08-23 4033
1. 结构体定义 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。 结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体有中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下： type struct_variable_name struct { member definition; member defin...
Go后台项目实战
cj_286的博客
05-28 2万+
本项目完全使用原生开发，没有使用任何WEB框架(如：gin，beego，Martini等)，和ORM(如：gorm,xorm,beego)三层架构三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为：界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）...
Go语言创建、初始化数组的各种方式
热门推荐
books1958的专栏
03-18 4万+
Go语言的语法很灵活，以下展示了创建并初始化数组的多种方式： //数组初始化的各种方式 func arraySliceTest0201() { //创建数组(声明长度) var array1 = [5]int{1, 2, 3} fmt.Printf("array1--- type:%T \n", array1) rangeIntPrint(array1[:]) //创建数组(不声明长
Go数组
忧郁沙的博客
11-25 179
数组 声明 如下代码出报错： num := 10 var name [num]string 报发下错误代码: 是说数组长度不是一个定值. 一维数组 //以下是声明及初始化的格式 var name [n]type //只声明不赋值，会按类型赋默认值：int:0 string: "", bool： false var name [n]type = [n]type{} //声明同时初始化 var name [n]type = [n]type{index: value} //声明时对指定索引的元素
Go语言 数组初始化和基本操作
m0_38068812的博客
11-11 5180
package main import "fmt" func main() { // 数组同一类型的集合 var arr [50]int // 1 赋值 // 操作数组，下标从0开始，索引从0到len()-1 for i := 0; i &lt; len(arr); i++ { arr[i] = i + 1 fmt.Printf("arr[%v] = %v\n", i, a...
RL78-G13 Demo板使用指南.pdf
03-26
RL78_G13 Demo板使用指南.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小柏ぁ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值