golang-数组

一、数组****
在go语言中 数组的长度必须是常量，并且长度是数组类型的一部分，一旦定义了数组的长度则不能改变
如

func main() {
	var a [3]int64 // 定义一个长度为3 元素类型为int64的数组
	fmt.Println(a, reflect.TypeOf(a))

}

其中[3]int64 表示了数组的类型

1. 1 数组的默认值
   从上述中可以得出在声明完数组之后数组会默认进行值填充，默认声明长度多长即用多少个0值元素进行填充
   数组的赋值操作方式
   在golang中一旦定义了数组的长度之后 在赋值时其赋值长度不能超过定义的数组长度

	var a [3]int64 // 定义一个长度为3 元素类型为int64的数组
	fmt.Println(a, reflect.TypeOf(a))

	//数组的赋值方式
	a[0] = 10
	a[1] = -10
	a[2] = -10
	a[3] = -10
	fmt.Println(a)

此时运行即会报错

数组的默认值*
``

点击查看代码

package main

import (
	"fmt"
	"reflect"
)

// 数组  数组的长度必须是常量，并且长度是数组类型的一部分，一旦定义了数组的长度则不能改变
func main() {
	var a [3]int64   // 定义一个长度为3 元素类型为int64的数组
	var b [2]bool    // 定义一个长度为的bool类型数组
	var c [10]string // 定义一个长度为10的string的数组
	fmt.Println(a, reflect.TypeOf(a))
	fmt.Println(b, reflect.TypeOf(b)) // [false false] [2]bool
	fmt.Println(c, reflect.TypeOf(c)) //[         ] [10]string

	//数组的赋值方式
	fmt.Println(a)

}

• 数组的取值
  在go语言中数组是可以通过下标进行相关的取值操作的

点击查看代码

	//数组的取值
	fmt.Println(a[1])        // 通过下标取出数组的第二个元素
	fmt.Println(a[len(a)-1]) // 通过下标取出数组的最后一个元素

数组支持索引访问，索引的合法范围0~len(array-1),不支持负数索引 在Python中的负数索引也是通过len(array-n)来进行实现

• 数组的赋值

点击查看代码

	//数组的赋值方式
	var x = [3]int{1, 2, 3}    // [1 2 3]
	y := [5]int{1, 2, 3, 4, 5} //[1 2 3 4 5]
	// 给索引为99的赋值为1 索引98的元素赋值为-2
	var x100 = [100]int{99: 1, 98: -2} //	[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -2 1]
	// 支持使用常量作为数组的长度
	const size = 100
	var xx = [size]int{}
	// 让编译器自动的去帮我们数一下有几个元素
	var yy = [...]string{"xx", "yy", "zz"} //[xx yy zz]
	var z = [...]int{1: 1, 3: 3, 10: 10} //11 [0 1 0 3 0 0 0 0 0 0 10]
	fmt.Println(len(z), z)

}

* 数组的遍历 在go语言中数组存在2种遍历方式

点击查看代码

	var aStr = [...]string{"北京", "上海", "深圳"}
	// for i 遍历
	for i := 0; i < len(aStr); i++ {
		fmt.Println(aStr[i])

	}
	// for range 遍历
	for index, value := range aStr {
		fmt.Println(index, value)
	}


• 多维数组

点击查看代码

package main

import (
	"fmt"
)

func main() {
	// 多维数组的声明方式1
	a := [3][3]string{
		{"北京", "上海", "深圳"},
		{"惠州", "南京", "广西"},
		{"石家庄", "苏州", "长沙"},
	}
	// 多维数组的声明方式2
	a2 := [3][2]int{
		[2]int{1, 2},
		[2]int{3, 4},
		[2]int{5, 6},
	}
	// 多维数组的遍历
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
		/*
			[北京 上海 深圳]
			[惠州 南京 广西]
			[石家庄 苏州 长沙]
		*/
		for j := 0; j < len(a[i]); j++ {
			fmt.Println(a[i][j])
		}

	}
	for index, value := range a {
		//fmt.Printf("a[%v]:%v", index, value)
		for index2, value2 := range value {
			fmt.Printf("a[%v][%v]:%v \n", index, index2, value2)
		}
	}

	fmt.Println(a, a2)

}

数组的的类型

什么是是值类型 什么是引用类型
引用类型：即赋值或者修改的时候会将内存地址赋予赋值值对象即赋值对象的内存地址==原地址 在修改赋值对象时原地址的元素也会发生更改
值类型：在使用赋值对象操作值类型时 会将原先的内存地址重新生成一份给到赋值对象，因为2者的内存地址不同在修改对象的元素的时候并不会影响原先的被赋值对象

点击查看代码

func modifyArray(x [3]int) {
	x[0] = 100
}

func modifyArray2(x [3][2]int) {
	x[2][0] = 100
}
func main() {
	a := [3]int{10, 20, 30}
	modifyArray(a) //在modify中修改的是a的副本x
	fmt.Println(a) //[10 20 30]
	b := [3][2]int{
		{1, 1},
		{1, 1},
		{1, 1},
	}
	modifyArray2(b) //在modify中修改的是b的副本x
	fmt.Println(b)  //[[1 1] [1 1] [1 1]]
}

1、求出数组[1,3,5,7,8]的和

点击查看代码

package main

import "fmt"

func main() {
	numTuple := [...]int{1, 3, 5, 7, 8}
	var num int
	for _, value := range numTuple {
		num += value

	}
	fmt.Printf("numTuple 数组中元素总和为:%v", num)

}

2、找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。

点击查看代码

package main

import "fmt"

func main() {
	// 求数组[1, 3, 5, 7, 8]所有元素的和
	numTuple := [...]int{1, 3, 5, 7, 8}
	var num int
	for _, value := range numTuple {
		num += value

	}
	fmt.Printf("numTuple 数组中元素总和为:%v\n", num)
	// 找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。
	for i := 0; i < len(numTuple); i++ {
		for j := i; j < len(numTuple); j++ {
			if numTuple[i]+numTuple[j] == 8 {
				fmt.Println("2数相加总和为8的下标为", i, j)
			}

		}
	}
}