【原创】go语言学习(七)数组

目录

• 数组定义
• 二维数组
• 数组拷贝、传参

数组定义

1. 数组是同一类型的元素集合。

var a [3]int
//定义一个数组

//Go中数组下标从0开始，因此⻓长度为n的数组下标范围：[0,n-1]

//整数组中的元素默认初始化为0，字符串串数组中的元素默认初始化为””

　　

2. 数组初始化

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
//数组初始化

var a [3]int = [3]int{10, 20, 30}
//定义时数组初始化

a := [3]int{10, 20, 30}
//定义时数组初始化

a := […]int{10, 20, 30}
//定义时数组初始化

a := [3]int{10}
//定义时数组初始化

a := [3]int{2:10}
//定义时数组初始化

　　

3. 数组⻓长度是类型的一部分

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
var b [5]int
b = a
//a、b是不同类型的数组，不能赋值

　　

4、len内置函数

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
fmt.Printf(“len:%d
”, len(a))
//a、b是不同类型的数组，不能赋值

　　

5. 数组遍历

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
for i := 0; i < len(a); i++ {
}
//a、b是不同类型的数组，不能赋值

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
for index, val := range a {
}
//a、b是不不同类型的数组，不不能赋值

二维数组

1、 二维数组

var a [3][2]int
a[0][0] = 10
a[0][1] = 20
a[1][0] = 30
a[1][1] = 30
a[2][0] = 30
a[2][1] = 30
for index, val := range a {
}
//a、b是不不同类型的数组，不不能赋值

　　

2、二维数组（二）

// 数组遍历写法二

func testArra10() {
	// 数组 a [长度]类型
	// 定义完成, 值为[0,0,0,100,300],指定特定下标
	a := [5]int{3: 100, 4: 300}
	for index, value := range a {
		fmt.Printf("a[%d]=%d
", index, value)
	}
}

　　

3、二维数组（三）

// 二维数组定义
func testArra11() {
	var a [3][2]int
	a[0][0] = 10
	a[0][1] = 20
	a[1][0] = 30
	a[1][1] = 40
	a[2][0] = 50
	a[2][1] = 60

	fmt.Println(a)

	// 遍历二维数组
	for i := 0; i < 3; i++ {
		for j := 0; j < 2; j++ {
			fmt.Printf("%d", a[i][j])
		}
		fmt.Println()
	}

	//遍历方式二
	fmt.Println("other method")
	for i, val := range a {
		// %v自动匹配格式输出，行
		fmt.Printf("row[%d]=%v
", i, val)
		for j, val2 := range val {
			fmt.Printf("(%d,%d)=%d", i, j, val2)
		}
	}

}

　　

数组拷贝、传参

1、数组是值类型

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
b := a
//b拷贝了了数组a中所有元素
b[0] = 1000
fmt.Println(a, b)

　　

2、 数组是值类型，函数传参也会拷贝

// 值类型,copy为全拷贝，改变b不会影响a
func testArra12() {
	a := [3]int{10, 20, 30}
	b := a
	b[0] = 1000
	fmt.Printf("a=%v
", a)
	fmt.Printf("b=%v
", b)
}

// int类型都是值类型,copy为全拷贝，改变b不会影响a
func testArray13() {
	var a int = 1000
	b := a
	b = 3000
	fmt.Printf("a=%d b=%d
", a, b)
}

// 数组传参为copy
func modify(b [3]int) {
	b[0] = 1000
}

　　

例子：

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func sumArray(a [10]int) int {
	var sum int = 0
	//第一种遍历
	for i := 0; i < len(a); i++ {
		sum = sum + a[i]
	}

	//第二种遍历, _ 屏蔽下标
	//for _, val := range a{
	//	sum = sum + val
	//}

	return sum
}

// 随机10数相加
func testArraySum() {

	//初始化随机种子,time.Now().Unix()纳秒时间
	rand.Seed(time.Now().Unix())

	var b [10]int
	for i := 0; i < len(b); i++ {
		//b[i] = i
		//随机 rand
		// 产生一个0到999的随机数
		b[i] = rand.Intn(1000)
		// 产生一个0到Int最大值的随机数
		// b[i] = rand.Int()
	}

	sum := sumArray(b)
	fmt.Printf("sum=%d
", sum)
}

// 两个元素之和，等于8 target的下标
func TwoSum(a [5]int, target int) {
	for i := 0; i < len(a); i++ {
		other := target - a[i]
		for j := i + 1; j < len(a); j++ {
			if a[j] == other {
				fmt.Printf("(%d, %d)
", i, j)
			}
		}
	}
}

//
func testTwoSum() {
	// var b [5]int = [5]int{1,3,5,8,7}
	// b := [5]int{1,3,5,8,7}
	b := [...]int{1, 3, 5, 8, 7}
	TwoSum(b, 8)
}

func main() {
	//sumArray()
	//testArraySum()
	testTwoSum()
}