zoukankan      html  css  js  c++  java
  • Golang复合类型-数组

    一、数组(Array)

    1.1 什么是数组

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

    数组元素可以通过索引(位置)来读取(或者修改),索引从0开始,第一个元素索引为 0,第二个索引为 1,以此类推。数组的下标取值范围是从0开始,到长度减1。

    数组一旦定义后,大小不能更改。

    1.2 数组的语法

    声明和初始化数组

    需要指明数组的大小和存储的数据类型。

    var variable_name [SIZE] variable_type
    

    示例代码:

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

    初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
    如果忽略 [] 中的数字不设置数组大小,Go 语言会根据元素的个数来设置数组的大小:

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

    数组的其他创建方式:

      var a [4] float32 // 等价于:var arr2 = [4]float32{}
      fmt.Println(a) // [0 0 0 0]
      var b = [5] string{"ruby", "王二狗", "rose"}
      fmt.Println(b) // [ruby 王二狗 rose  ]
      var c = [5] int{'A', 'B', 'C', 'D', 'E'} // byte
      fmt.Println(c) // [65 66 67 68 69]
      d := [...] int{1,2,3,4,5}// 根据元素的个数,设置数组的大小
      fmt.Println(d)//[1 2 3 4 5]
      e := [5] int{4: 100} // [0 0 0 0 100]
      fmt.Println(e)
      f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
      fmt.Println(f)
    

    1.3 多维数组

    Go 语言支持多维数组,以下为常用的多维数组声明语法方式:

    var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
    
    var threedim [5][10][4]int
    

    1.4 数组是值类型

    数组是值类型
    Go中的数组是值类型,而不是引用类型。这意味着当它们被分配给一个新变量时,将把原始数组的副本分配给新变量。如果对新变量进行了更改,则不会在原始数组中反映。

    package main
    
    import "fmt"
    
    func main() {  
        a := [...]string{"USA", "China", "India", "Germany", "France"}
        b := a // a copy of a is assigned to b
        b[0] = "Singapore"
        fmt.Println("a is ", a)
        fmt.Println("b is ", b) 
    }
    

    运行结果:

    a is [USA China India Germany France]  
    b is [Singapore China India Germany France] 
    

    数组的大小是类型的一部分。因此[5]int和[25]int是不同的类型。因此,数组不能被调整大小。不要担心这个限制,因为切片的存在是为了解决这个问题。

    package main
    
    func main() {  
        a := [3]int{5, 78, 8}
        var b [5]int
        b = a //not possible since [3]int and [5]int are distinct types
    }
    

    例子1:

    package main
    
    import "fmt"
    
    func main() {
    	/*
    		数据类型:
    			基本类型:整数、浮点、布尔、字符串
    			复合类型:array、slice、map、strut、ponter、function、channel...
    		数组:
    			1.概念:存储一组相同数据类型的数据结构,理解为容器,存储一组数据
    			2.语法:
    				var 数组名 [长度] 数据类型
    				var 数组名 = [长度] 数据类型{元素1,元素2...}
    				数组名 := [...]数据类型{元素1,元素2}
    			3.访问:
    				下标、也叫索引:index
    				默认从0开始,直到长度减1
    				数组名[index]
    			4.长度和容量:go语言的内置函数
    				len(array|map|)
    				cap(array|map)
    	*/
    	//step1:创建数组
    	var arr1 [4]int
    	//step2:数组的访问
    	arr1[0] = 1
    	arr1[1] = 2
    	arr1[2] = 3
    	arr1[3] = 4
    	fmt.Println(arr1[0])                //打印第一个元素,访问数组时不能超过下标
    	fmt.Println(arr1[1])                //打印第二个元素
    	fmt.Println("数组arr1的长度", len(arr1)) //容器中实际存储的数据量
    	fmt.Println("数组arr1的容量", len(arr1)) //容器中能够存储的最大的数量
    	//因为数组是定长的,所以它的长度和容量相同
    	//数组的其他创建方式
    	var arr2 [4]int   //同 var arr2 = [4] int
    	fmt.Println(arr2) //没有赋值时为0
    	var arr3 = [4]int{1, 2, 3, 4}
    	fmt.Println(arr3)
    	arr4 := [...]int{1: 2, 3: 4} //[0 2 0 4]
    	fmt.Println(arr4)
    }
    
    

    例子2:

    
    package main
    
    import "fmt"
    
    func main() {
    	/*
    		依次访问数组中的元素
    		方法一:arr[0]、arr[1]、arr[2]。。。
    		方法二:通过循环,配合下标
    			for i:=0;i<len(arr);i++ {
    				arr[i]
    			}
    		方法三:使用range
    			不需要操作数组的下标,到达数组的末尾,自动结束for range循环,每次都数组中获取下标和对应的数值。
    	*/
    	//方法一
    	arr1 := [5]int{1, 2, 3, 4, 5}
    	fmt.Println(arr1[0], arr1[1], arr1[2], arr1[3], arr1[4])
    	fmt.Println("-------------")
    	//方法二
    	for i := 0; i < len(arr1); i++ {
    		fmt.Println(arr1[i])
    	}
    	fmt.Println("-------------")
    	//方法三:
    	for index, value := range arr1 {
    		fmt.Printf("下标是:%d,数值是:%d
    ", index, value)
    	}
    	//计算数组元素的和
    	sum := 0
    	for _, value := range arr1 { //通过_舍弃这个下标
    		sum += value
    	}
    	fmt.Printf("数组的和是:%d
    ", sum)
    }
    
    

    例子3:

    package main
    
    import "fmt"
    
    func main() {
    	/*
    		数组的排序:
    			让数组中的元素有一定的顺序
    			arr := [5]{15,23,20,9,8}
    		排序算法:
    			冒泡排序、插入排序、选择排序、希尔排序、堆排序、快速排序
    		冒泡排序
    			依次比较两个相邻的元素
    	*/
    	arr := [5]int{15, 23, 20, 9, 8}
    	for i := 1; i < len(arr); i++ {
    		for j := 0; j < len(arr)-1; j++ {
    			if arr[j] > arr[j+1] {
    				arr[j], arr[j+1] = arr[j+1], arr[j]
    			}
    		}
    	}
    	fmt.Println(arr)
    }
    
    

    例子4:

    package main
    
    import "fmt"
    
    func main() {
    	/*
    		一维数组:存储多个数据是数值本身
    		a1 := [3]int{1,2,3}
    		二维数组:存储的是一维的一维
    		a2 := [3][4]int{{},{},{}}
    		该二维数组的长度,就是3
    		存储的元素是一维数组,一维数组的元素是数值,每个一维数组长度为4
    	*/
    	a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
    	fmt.Println(a2)
    	fmt.Printf("二维数组的地址:%p
    ", &a2)
    	fmt.Printf("二维数组的长度:%d
    ", len(a2))
    	fmt.Printf("一维数组的长度:%d
    ", len(a2[0]))
    	//遍历数组
    	fmt.Println("我是分割线,遍历数组")
    	for i := 0; i < len(a2); i++ {
    		for k := 0; k < len(a2[i]); k++ {
    			fmt.Print(a2[i][k], "	")
    		}
    		fmt.Println()
    	}
    }
    
    
  • 相关阅读:
    商贸通帐套隐藏方法
    固定资产打开提示:上年度数据未结转!
    ZOJ 2432 Greatest Common Increasing Subsequence
    POJ 1080 Human Gene Functions
    POJ 1088 滑雪
    POJ 1141 Brackets Sequence
    POJ 1050 To the Max
    HDOJ 1029 Ignatius and the Princess IV
    POJ 2247 Humble Numbers
    HDOJ 1181 变形课
  • 原文地址:https://www.cnblogs.com/walker1024/p/14359909.html
Copyright © 2011-2022 走看看