Golang基础-4

Go语言基础

介绍

基础

• 数组(array)

  • 数组声明

  • 元素访问与修改

  • 数组遍历

  • 关系运算

  • 切片创建

  • 多维数组

介绍

• 本文介绍Go语言中数组(array)操作(数组声明、元素访问与修改、数组遍历、关系运算、切片创建、多维数组)等相关知识。

基础

数组

• 数组是具有相同数据类型的数据元素组成的一组长度固定的序列，数组的长度必须是非负整数的常量，长度也是类型的一部分。
• 数组声明后，其数据类型与元素数量固定不可变。

数组声明

package main

import "fmt"

func main() {
	// 声明数组
	var arr0 [5]float32
	fmt.Printf("%T, %v\n", arr0, arr0)
	// 声明并初始化数组，指定数组长度
	var arr1 [5]int = [5]int{1, 2, 3, 4, 5}
	fmt.Printf("%T, %v\n", arr1, arr1)
	// 自动推导参数类型，初始化前三个元素，后两个默认为空
	arr2 := [5]string{"fsd", "fdsds", "fds"}
	fmt.Printf("%T, %v\n", arr2, arr2)
	// 数组长度不确定时自动推导
	arr3 := [...]byte{'A', 'B'}
	fmt.Printf("%T, %c\n", arr3, arr3)
	// 指定元素位置初始化
	arr4 := [5]int{0: 10, 3: 13, 4: 14}
	fmt.Printf("%T, %v\n", arr4, arr4)
	// 数组长度不确定时，指定元素位置初始化并自动推导
	arr5 := [...]int{0: 1, 4: 3}
	fmt.Printf("%T, %v\n", arr5, arr5)
}

输出结果
[5]float32, [0 0 0 0 0]
[5]int, [1 2 3 4 5]
[5]string, [fsd fdsds fds ]
[2]uint8, [A B]
[5]int, [10 0 0 13 14]
[5]int, [1 0 0 0 3]

数组声明

• 通过数组下标（索引位置）来访问或修改数组的元素
• 数组的起始索引从0开始

package main

import "fmt"

func main() {
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr)

	// 以索引访问数组
	fmt.Println("arr[0] = ", arr[0])
	fmt.Println("arr[1] = ", arr[1])
	fmt.Println("arr[2] = ", arr[2])
	fmt.Println("arr[3] = ", arr[3])
	fmt.Println("arr[4] = ", arr[4])

	// 修改数组
	arr[0] = 100
	arr[1] = 200
	arr[4] = 300
	fmt.Println("arr[0] = ", arr[0])
	fmt.Println("arr[1] = ", arr[1])
	fmt.Println("arr[2] = ", arr[2])
	fmt.Println("arr[3] = ", arr[3])
	fmt.Println("arr[4] = ", arr[4])
}

输出结果
[1 2 3 4 5]
arr[0] = 1
arr[1] = 2
arr[2] = 3
arr[3] = 4
arr[4] = 5
arr[0] = 100
arr[1] = 200
arr[2] = 3
arr[3] = 4
arr[4] = 300

数组遍历

• 使用 for循环遍历数组

package main

import "fmt"

func main() {
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr)

	// 获取数组大小
	fmt.Println(len(arr))

	// for循环遍历
	for i := 0; i < len(arr); i++ {
		fmt.Println("arr[", i, "] = ", arr[i])
	}

	fmt.Println("========================")
	// for-range遍历
	for i, v := range arr {
		fmt.Println("arr[", i, "] = ", v)
	}
}

输出结果
[1 2 3 4 5]
5
arr[ 0 ] = 1
arr[ 1 ] = 2
arr[ 2 ] = 3
arr[ 3 ] = 4
arr[ 4 ] = 5
========================
arr[ 0 ] = 1
arr[ 1 ] = 2
arr[ 2 ] = 3
arr[ 3 ] = 4
arr[ 4 ] = 5

关系运算

• 可判断同数据类型数组间是否相同(==、!=)

package main

import "fmt"

func main() {
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	fmt.Println("== ", arr == [...]int{1, 2, 3, 4, 5})
	fmt.Println("!= ", arr != [...]int{1, 2, 3, 4, 5})
}

输出结果
== true
!= false

切片创建

• array[start : end] 或 array[start : end : cap](end<=cap<=len)获得部分元素做为切片

package main

import "fmt"

func main() {
	var arr [5]int = [5]int{1, 2, 3, 4, 5}

	// 获取数组长度和数组容量
	fmt.Printf("arr len: %v, cap: %v\n", len(arr), cap(arr))
	fmt.Println("=====================")
	// 从数组创建切片，array[start:end]
	s1 := arr[0:2]
	fmt.Printf("s1 type: %T, value: %v, len: %v, cap: %v\n", s1, s1, len(s1), cap(s1))
	// 从数组创建切片，array[start:end:cap]
	s2 := arr[0:1:2]
	fmt.Printf("s2 type: %T, value: %v, len: %v, cap: %v\n", s2, s2, len(s2), cap(s2))
}

输出结果
arr len: 5, cap: 5
=====================
s1 type: []int, value: [1 2], len: 2, cap: 5
s2 type: []int, value: [1], len: 1, cap: 2

多维数组

• 数组的元素也可以是数组类型，这就是多维数组
• 多维数组声明

package main

import "fmt"

func main() {
	// 声明一个二维数组
	var arr [2][2]int = [2][2]int{}
	fmt.Println("arr: ", arr)

	// 声明一个二维数组，并初始化
	var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr1: ", arr1)

	// 自动推导类型
	arr2 := [2][2]int{}
	fmt.Printf("arr2 type: %T, value: %v\n", arr2, arr2)

	// 多维数组只有第一维长度可使用变量数自动推导
	arr3 := [...][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Printf("arr3 type: %T, value: %v\n", arr3, arr3)

	// 按数组第一维索引初始化
	arr4 := [3][3]int{0: {1, 1, 1}, 2: {3, 3, 3}}
	fmt.Printf("arr4 type: %T, value: %v\n", arr4, arr4)

	// 按数组多维度索引初始化
	arr5 := [3][3]int{0: {0: 10, 2: 20}, 2: {3, 3, 3}}
	fmt.Printf("arr5 type: %T, value: %v\n", arr5, arr5)
}

输出结果
arr: [[0 0] [0 0]]
arr1: [[1 2 3] [4 5 6]]
arr2 type: [2][2]int, value: [[0 0] [0 0]]
arr3 type: [2][3]int, value: [[1 2 3] [4 5 6]]
arr4 type: [3][3]int, value: [[1 1 1] [0 0 0] [3 3 3]]
arr5 type: [3][3]int, value: [[10 0 20] [0 0 0] [3 3 3]]

• 多维数组访问与修改

package main

import "fmt"

func main() {
	// 声明一个二维数组，并初始化
	var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr1: ", arr1)

	// 访问维度
	fmt.Println("arr1[0]: ", arr1[0])
	// 访问某个元素
	fmt.Println("arr1[0][2]: ", arr1[0][2])

	// 修改维度
	arr1[0] = [3]int{10, 20, 30}
	fmt.Println("arr1: ", arr1)
	// 修改某个元素
	arr1[0][2] = 100
	fmt.Println("arr1: ", arr1)
}

输出结果
arr1: [[1 2 3] [4 5 6]]
arr1[0]: [1 2 3]
arr1[0][2]: 3
arr1: [[10 20 30] [4 5 6]]
arr1: [[10 20 100] [4 5 6]]

• 多维数组遍历

package main

import "fmt"

func main() {
	// 声明一个二维数组，并初始化
	var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr1: ", arr1)

	// for循环遍历
	for i := 0; i < len(arr1); i++ {
		for j := 0; j < len(arr1[i]); j++ {
			fmt.Printf("arr1[%v][%v] = %v\t", i, j, arr1[i][j])
		}
		fmt.Println()
	}

	fmt.Println("=======================")
	// for-range循环遍历
	for i, row := range arr1 {
		for j, v := range row {
			fmt.Printf("arr1[%v][%v] = %v\t", i, j, v)
		}
		fmt.Println()
	}
}

输出结果
arr1: [[1 2 3] [4 5 6]]
arr1[0][0] = 1 arr1[0][1] = 2 arr1[0][2] = 3
arr1[1][0] = 4 arr1[1][1] = 5 arr1[1][2] = 6
=======================
arr1[0][0] = 1 arr1[0][1] = 2 arr1[0][2] = 3
arr1[1][0] = 4 arr1[1][1] = 5 arr1[1][2] = 6

起始