复合数据类型

数组

数组是具有相同类型的一组 已知编号
且 长度固定
的数据项序列，这个序列可以是有序的也可以是无序的，组成数组的各个变量称为数组的元素。数组的长度必须是一个 非负整数的
常量（或常量表达式），数组长度也是数组类型的一部分，所以[4]int和[10]int不是同一种类型。 

//声明一个长度为20的整型数组
var array [20]int
//声明一个包含5个元素的整型数组
//用字面量初始化每个数据元素
array := [5]int{2,3,9,8,1}
//声明一个整型数组
//用具体值初始化每个元素
//容量由初始化值的数量决定
array := [...]int{10,20,30,40,70}
//声明一个有5个元素的数组
//用具体值初始化索引为2和5的元素
//其余元素保持零值
array := [5]int{2:20, 5:10}
//声明数组（没有初始化）
//必须指定长度和类型
//数组长度也是类型的一部分，即长度相同，数组类型才是相同
func main()  {
    var array [3]bool
    var arrayInt  [3]int
    var arrayString  [4]string
    //初始化
    testArray := array
    testArray = [3]bool{true,false,true}
    testInt := arrayInt
    testInt = [...]int{10,20,30}  //语法糖，使用可变参数 "..." 替代声明数组长度
    testString := arrayString
    testString = [...]string{"完","满","主","任"}
    idx := testString
    idx = [...]string{0:"小",1:"马",3:"哥"}  //根据索引初始化，未被初始化元素为零值（索引值4）
    //打印数组类型
    fmt.Printf("%T %T\n",array,arrayInt)
    //打印数组未初始化，默认打印类型零值(int型:0，bool型:false，string型:"")
    fmt.Println(array,arrayInt,arrayString)
    //打印初始化数组值
    fmt.Println(testArray,testInt,testString,idx)
}

/*
[3]bool [3]int
[false false false] [0 0 0] [   ]
[true false true] [10 20 30] [完 满 主 任] [小 马  哥]
*/

### 遍历数组
Go语言数组通过下标（索引位置）来读取或者修改数组元素，下标（索引）从0开始，第一个元素为0，则第 i 个元素 的索引值为 i-1

func main(){
    //index遍历
var array [3]string
    array = [...]string{"钓","鱼","城"}
for i,v := range array{
        fmt.Println(i,v)
}
    //range遍历
var array1  [4]string
    array1 = [...]string{"完","满","主","任"}
    for i := 0 ; i<len(array1) ; i++ {
        fmt.Println(i,array1[i])
    }
}

/*
0 钓
1 鱼
2 城
0 完
1 满
2 主
3 任
*/
，如果写成
func main (){
    var strss= []string{
        "钓",
        "鱼",
        "城",

    }
    var strss2= []string{
        "完",
        "满",
        "主",
        "任",
    }
    strss = append(strss,strss2...) //使用append函数连接字符串，...代表可以传递任意数量的参数
    fmt.Println(strss)
}
  
/*
  [钓 鱼 城 完 满 主 任]
  */
func main () {
    arr := [5]int{1, 2, 3, 4} //按照索引初始化数组元素
arr[4] = 88  //修改索引为4的值为88
    for i := 0; i < len(arr); i++ {
    fmt.Printf("Arrar at index %d is %d\n", i, arr[i])
    }
}

/*
Arrar at index 0 is 1
Arrar at index 1 is 2
Arrar at index 2 is 3
Arrar at index 3 is 4
Arrar at index 4 is 88
*/
//使用数组字面量来声明并初始化一个二维整型数组
array := [3][2]int{{2,5},{1,7},{9,8}}
//声明并初始化外层数组中索引为0和1的元素
array := [3][2]int{0:{2,5},1:{1,7}}
//声明并初始化外层数组和内层数组的单个元素
待补充，需要敲代码验证

值类型

在Go语言里，数组是一个类型值，意味着数组也可以像函数一样用在赋值操作中，变量名代表整个数组，因此，同样类型的数组可以赋值给另一个数组。

//声明第一个包含5个元素的字符串数组
var array1 [5]string
//声明第二个包含5个元素的字符串数组
//用名字初始化数组
array2 := [5]string{"完","满","大","法","好"}
//只有数据类型和数组长度都相同，才能进行复制，将array2的值复制到array
array = array2

数组的值也可以是指针，声明一个所有元素都指针变量的数组，使用 *运算符就可以访问元素指针所指向的值

//声明一个包含5个元素的指向整数的数组
//用整型指针初始化索引为0和1的数组元素
array := [5]*int{0: new int}
//为索引为0和1的元素赋值
*array[0] = 10
*array[1] = 20

如果复制数组指针，只会复制数组的值，而不会复制指针所指向的值。

//声明第一个包含3个元素的指向字符串类型的指针数组
var array1 [3]*string
//声明第二个包含3个元素的指向字符串类型的指针数组
//使用字符串指针初始化这个数组
array2 := [3]*string{new(string),new(string),new(string)}
//使用名字为第二个数组元素赋值
*array2 [0] = "完"
*array2 [1] = "满"
*array2 [2] = "人"
//复制完成后，两个数组指向同一组字符串 → ("完","满","人")
array1 = array2

### 练习（demo）
编写一个函数，实现数组元素并累加求和的功能

func main(){
 var a1 = [...]int{1,5,3,6,2}
 sum := 0
 for _,v := range a1{
     sum += v
 }
 fmt.Println(sum)
}
/*
17
*/

编写一个函数，遍历数组求第i个元素和第j个元素相加和为8的值

func main(){
 var a1 = [...]int{1,5,3,6,2}
 //两层for循环求索引
 for i:= 0 ; i<len(a1) ; i++ {
     for j:=0 ; j<len(a1) ; j++ {
         if a1[i] + a1 [j] == 8{  //第i个元素值 + 第j个元素值 == 8
             fmt.Printf("(%d, %d)\n",i,j)
         }
     }
 }
}
/*
(1, 2)
(2, 1)
(3, 4)
(4, 3)
*/