4.Go语言数组和切片(一)

main.go

// Go语言数组和切片
package main

//  包的本质是创建不同的文件夹
//  go的每一个文件都是属于一个包的
//  go以包的形式管理项目和文件目录。
//  import "包的路径"
import (
    // 别名  包的路径
    utils "day15/model/utils" 
    _"fmt"
)


var content string = `
————————————————Go语言数组和切片————————————————————
一、数组
二、切片

`


/**
 * [init init函数初始化工作。main函数之前执行]
 * @author Jhou Shuai
 * @datetime 2019-05-20T22:49:36+0800
 */
// func init() {
//  fmt.Println(content)
// }


func main() {
    utils.Entry()
}

utils.go

// Go语言数组和切片
package utils

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

var layout string = "2006-01-02"

// 全局变量
var Author string = "Jhou Shuai"

// 全局变量
var Description string = "Go语言数组和切片"

//全局变量：使用反引号来定义多行字符串
var Content string = `
————————————————Go语言数组和切片————————————————————
一、数组
    1)数组是值类型：
    2)数组可以存放多个同一类型的数据
    3)增加程序可维护性
    4)代码更加清晰，易扩展
二、切片
`

/**
 * [Init 入口]
 * @author Jhou Shuai
 * @datetime 2019-05-18T11:58:33+0800
 */
func Entry() {
    arrayUseDesc()
}


/**
 * [initArrayFourMethod 四种初始化数组的方式]
 * @author Jhou Shuai
 * @datetime 2019-05-28T19:49:34+0800
 */
func  initArrayFourMethod() {
    var numArr1 [3]int = [3]int{1,2,3}
    fmt.Println("numArr1= ",numArr1)

    var numArr2 = [3]int{4,5,6}
    fmt.Println("numArr2= ",numArr2)

    // [...]是固定的写法
    var numArr3 = [...]int{7,8,9}
    fmt.Println("numArr3= ",numArr3)


    var numArr4 = [...]int{1:2333,0:666,3:888,4:666,2:555}
    fmt.Println("numArr4= ",numArr4)

    strArr5 := [...]string{1:"Tom",0:"Faker",2:"Jerry",3:"Uzi"}
    fmt.Println("strArr5= ",strArr5)
}


/**
 * [arrayUseDesc 数组]
 * @author Jhou Shuai
 * @datetime 2019-05-27T19:37:25+0800
 */
func arrayUseDesc() {
    // 1.定义一个数组
    var scores [6]float64;
    // 2.给数组的每个元素赋值
    // 元素的下标是从零开始的
    scores[0] = 88
    scores[1] = 90
    scores[2] = 80
    scores[3] = 98
    scores[4] = 68
    scores[5] = 77
    // 3.遍历数组
    totalScore := 0.0
    for i := 0; i <len(scores); i++ {
        totalScore +=scores[i]
    }
    avgScore := fmt.Sprintf("%.2f", totalScore/float64(len(scores)))
    fmt.Println("平均成绩：",avgScore)

    // int 占8个字节 64位整数
    var intArr [6]int
    fmt.Println(intArr)
    // 1）数组的地址是 &数组名
    // 2）数组的第一个元素的地址就是数组的首地址。
    //      intArr地址：0xc000094030
    //      intArr[0]的地址：0xc000094030
    // 3）第二个元素的地址=第一个元素地址+数组类型占用的字节数
    //      intArr[0]的地址0xc000094030  
    //      intArr[1]的地址0xc000094038   0xc000094038 = 0xc000094030 + 8
    //      intArr[2]的地址0xc000094040   0xc000094040 = 0xc000094038 + 8
    //      intArr[3]的地址0xc000094048   0xc000094048 = 0xc000094040 + 8
    //      intArr[4]的地址0xc000094050   0xc000094050 = 0xc000094048 + 8
    //      intArr[5]的地址0xc000094058   0xc000094058 = 0xc000094050 + 8
    //4）数组的各个元素的地址间隔是依据数组的类型决定的，
    //      比如：int64->8个字节、int32->4个字节 int16 ->2个字节 、int->8个字节
    fmt.Printf("intArr地址%p，intArr[0]的地址%p \n",&intArr,&intArr[0])
    for i := 0; i <len(intArr); i++ {
        fmt.Printf("intArr[%v]的地址%p \n",i,&intArr[i])
    }
    /*
    结果：
    intArr地址0xc00000e420，intArr[0]的地址0xc00000e420
    intArr[0]的地址0xc00000e420
    intArr[1]的地址0xc00000e428
    intArr[2]的地址0xc00000e430
    intArr[3]的地址0xc00000e438
    intArr[4]的地址0xc00000e440
    intArr[5]的地址0xc00000e448
    */
    // 字符串：总共16个字节
    // 实际上字符串类型对应一个结构体，该结构体有两个域，
    // 第一个域是指向该字符串的指针，
    // 第二个域是字符串的长度，
    // 每个域占8个字节
    stringArry := [...]string{1:"Tom",0:"Faker",2:"Jerry",3:"Uzi"}
    fmt.Printf("stringArry地址%p，stringArry[0]的地址%p \n",&stringArry,&stringArry[0])
    for i := 0; i <len(stringArry); i++ {
        fmt.Printf("stringArry[%v]的地址%p \n",i,&stringArry[i])
    }
    /*
    stringArry地址0xc000066100，stringArry[0]的地址0xc000066100
    stringArry[0]的地址0xc000066100
    stringArry[1]的地址0xc000066110 0xc000066110 = 0xc000066100 + 16 
    stringArry[2]的地址0xc000066120 0xc000066120 = 0xc000066110 + 16 
    stringArry[3]的地址0xc000066130 0xc000066130 = 0xc000066120 + 16 
     */
}


/**
 * 数组的遍历
 * for...range
 */
func arrayTraversal() {
    strArr5 := [...]string{1:"Tom",0:"Faker",2:"Jerry",3:"Uzi"}
    /**
     * index 是数组的下标
     * value 是该下标位置的值
     * index，value 是for循环内部可见的局部变量
     * 如果不使用下标，可以用下划线“_”忽略
     *
     *  0 --> Faker
        1 --> Tom
        2 --> Jerry
        3 --> Uzi
     */
    for index,value := range strArr5 {
        fmt.Println(index,"-->",value)
    }

    // 如果不使用下标，可以用下划线“_”忽略
    for _,value := range strArr5 {
        fmt.Printf("元素的值为：%v \n", value)
    }
}


/**
 * [arrayUseDetail 数组的使用注意事项和细节]
 * @author Jhou Shuai
 * @datetime 2019-05-28T20:18:30+0800
 */
func arrayUseDetail() {
    // 1) 数组是多个相同类型数据的组合，一个数组一旦声明或定义咯，其长度是固定，不能动态增长
    // var intArry [3]int
    // intArry[0] = 1
    // intArry[1] = 30

    // // 多个相同类型数据的组合
    // // 报错了：constant 1.1 truncated to integer
    // // intArry[2] = 1.1  
    // // 
    // // 其长度是固定，不能动态增长
    // // 报错了： invalid array index 3 (out of bounds for 3-element array)
    // // intArry[3] = 40
    // fmt.Println(intArry)

    // 2）var arr []int arr是一个slice切片 

    // 3）数组中的元素可以是任何数据类型，包括值类型和引用类型，不是不能混用。
    // 4）数组创建以后，如果没有赋值，有默认值：
    // 数值类型（整数、浮点数）数组：  默认值为 0
    // 字符串数组：                   默认值为 ''
    // bool数组：                  默认值为 false
    

    // var floatArry [3]float32
    // var strArry [3]string
    // var boolArry [3]bool
    // // floatArry=[0 0 0],strArry=[  ],boolArry=[false false false]
    // fmt.Printf("floatArry=%v,strArry=%v,boolArry=%v",floatArry,strArry,boolArry)

    // 5）使用数组的步骤：
    //  1.声明数组并开辟空间（分配内存地址）
    //  2.给数组各个元素赋值（默认为零值）
    //  3.使用数组
    //  
    //  6）数组的下标是从零开始的
    //  var floatArry [3]float32 
    //  下标： 0-2
    //  
    //  7）数组下标必须在指定范围内使用，否则报panic：数组越界
    //  比如：var floatArry [3]float32  有效下标 0-2
    //  
    //  8）数组属于值类型，在默认情况下是值传递，因此会进行拷贝，数组间不会相互影响
    //  栈里面
    // var arr = [3]int{22,33,44}
    // test01(arr)
    // fmt.Println(arr)

    // 9）引用传递
    arr2 := [3]int{22,33,44}
    fmt.Printf("arr2的地址：%p \n",&arr2)
    test02(&arr2)
    fmt.Println(arr2)

    // 10）长度是数组类型的一部分，在传递函数参数时，需要考虑数组的
    // 长度。比如：
    // test01(arr [3]int) 
    // test01(arr [4]int) 与上面的数据类型不一样哦
    // test01(arr []int) #切片，不是组数
    // test01(arr *[3]int)
}

/**
 * [test01 值传递]
 * @author Jhou Shuai
 * @datetime 2019-05-28T21:08:13+0800
 */
func test01(arr [3]int) {
    arr[0] = 88
    fmt.Println(arr)
}

/**
 * [test02 引用传递]
 * @author Jhou Shuai
 * @datetime 2019-05-28T21:08:26+0800
 */
func test02(arr *[3]int) {
    fmt.Printf("arr的地址：%p \n,arr的存放的值：%v \n",&arr,*arr)
    // 数组指针取值
    (*arr)[0] = 88
}


func arryExercise() {
    // var myChars [26]byte
    // // 字符可以进行运算:'A'+1-->'B'
    // for i := 0; i < 26; i++ {
    //  // 将i=>byte
    //  myChars[i] = 'A'+ byte(i)
    // }

    // for i := 0; i < 26; i++ {
    //  // %c字符类型
    //  // A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    //  fmt.Printf("%c ", myChars[i])
    // }
    // fmt.Println()

    // var intArr = [5]int{1,-1,55,88,66}
    // maxVal := intArr[0]
    // maxValIndex := 0

    // for index,value :=range intArr {
    //  if maxVal<value {
    //      maxVal = value
    //      maxValIndex = index
    //  }
    // }
    // fmt.Printf("最大值：%v,索引：%v \n\n", maxVal,maxValIndex)


    // var scoreArr = [5]int{33,77,55,88,66}
    // sum := 0
    // for _,val :=range scoreArr {
    //  sum += val
    // }

    // // 求平均值，保留小数
    // fmt.Printf("和：%v,平均值：%v \n\n", sum,float64(sum)/float64(len(scoreArr)))

    var intRangeArr [5]int
    len := len(intRangeArr)
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len; i++ {
        intRangeArr[i] = rand.Intn(100)
    }
    fmt.Println(intRangeArr)

    tmp := 0
    // 数组反转次数 len/2
    // 第一个元素与倒数第一个元素
    // 第二个元素与倒数第二个元素
    for i := 0; i <len/2; i++ {
        tmp = intRangeArr[len-1-i]
        intRangeArr[len-1-i] = intRangeArr[i]
        intRangeArr[i] = tmp
    }
    fmt.Println(intRangeArr)
}