go code

package part2


/*
数组
数组切片
map
*/
import (
"fmt"
)


/*
[32]byte                     //长度32的数组,每个元素1个字节
[2*n] struct{x,y int32} //复杂类型数组
[1000]*float64 //指针数组
[3][5]int //2维数组
[2][2][2]float64 //等同[2]([2][2]float64)
*/
/*
a:=[10] int{1,2,3,4,5,6} 未提供初始化值的元素默认为0
b:=[...]int{1,2} 由初始化列表决定数组长度,不能省略"..."否则为slice
c:=[10]int{2:1,5:100} 按序号初始化元素
d:=[...]{19:1}           长度20第下标19(最后一个元素)为1,其余的数为0
*/
func ArrayBase() {


var a1 [1]int
var a2 [2]int
var a3 [2]int
// a1 = a2 不能相等,因为数组长度也是数组类型的一部分
a2 = a3 //可以赋值类型长度相同
fmt.Println("数组类型:", a1, a2, a3)
}


/*
数组指针,指针数组
*/
func PointerArray() {


x, y := 1, 2


var p1 *[2]int = &[2]int{x, y}   //数组指针类型
var p2 [2]*int = [2]*int{&x, &y} //指针数组类型


fmt.Printf("%#v\n", p1)
fmt.Printf("%#v\n", p2)


a := [...]int{9: 9} //数组
var p *[10]int = &a //数组的指针
fmt.Println("数组的指针", p)


b := [...]*int{&x, &y} //保持的是指针,是指针数组


fmt.Println("指针数组", b)


ps := new([10]int) //返回指向数组的指针
fmt.Println("new数组:", ps)
}


//判断数组是否相等
func EqualsArray() {
a := [2]int{1, 2}
b := [2]int{1, 2}
c := [2]int{1, 3}


fmt.Println(a == b) //true
fmt.Println(a == c) //false
}


//数组赋值
func SetValue() {
//2中方式对数组元素赋值
a := [2]int{}
a[1] = 2
fmt.Println(a)


p := new([2]int)
p[1] = 2
fmt.Println(p)
}


//多维数组
func Dimensions() {
a := [2][3]int{{1, 2, 3}, {4, 5, 67}}
fmt.Println("多维数组", a)


b := [2][3]int{{1: 2}, {2: 1}}
fmt.Println("多维数组下标赋值", b)
}


//冒泡排序
func BubbleSort(unsort [9]int) {


fmt.Println("排序前", unsort)
var size = len(unsort)
for i := size - 1; i > 0; i-- {
for j := 0; j < i; j++ {
if unsort[j] > unsort[j+1] {
unsort[j], unsort[j+1] = unsort[j+1], unsort[j]
}
}
}
fmt.Println("排序后", unsort)
}


/*
go中数组是一个值类型,在赋值或作为参数传递时将产生1次复制.
--函数体内操作的是所传入数组的副本
*/
func ArrayUseParam() {


array := [5]int{1, 2, 3, 4, 5}
setArray(array)
fmt.Println("原数组值是:", array)
}


func setArray(array [5]int) {
array[0] = 10
fmt.Println("修改中,数组值是:", array)

}

--------------------

package part2


/*
go类型:


布尔型：bool
- 长度：1字节
- 取值范围：true, false
- 注意事项：不可以用数字代表true或false


整型：int/uint
- 根据运行平台可能为32或64位


8位整型：int8/uint8
- 长度：1字节
- 取值范围：-128~127/0~255


字节型：byte（uint8别名）


16位整型：int16/uint16
- 长度：2字节
- 取值范围：-32768~32767/0~65535


32位整型：int32（rune）/uint32
- 长度：4字节
- 取值范围：-2^32/2~2^32/2-1/0~2^32-1
64位整型：int64/uint64
- 长度：8字节
- 取值范围：-2^64/2~2^64/2-1/0~2^64-1
浮点型：float32/float64
- 长度：4/8字节
- 小数位：精确到7/15小数位


复数：complex64/complex128
- 长度：8/16字节
足够保存指针的 32 位或 64 位整数型：uintptr


其它值类型：
- array、struct、string


引用类型：
- slice、map、chan


接口类型：inteface


函数类型：func




时间：2013-11-07 14:50:42
*/


/*
类型零值:


        零值并不等于空值，而是当变量被声明为某种类型后的默认值，
通常情况下值类型的默认值为0，bool为false，string为空字符串


*/


import (
"fmt"
"math"
)


//类型别名
type (
bs   int8
rune int32
文本   string
)


func Pri() {
/*
var a int
可省略变量类型,由系统推断
a = 123


var b int = 321


var c = 321
变量声明赋值的最简形式
d := 456
*/


var bb 文本
bb = "中文啊亲"
var a string = "aaaaaaaaaaaaa"


var num int = 123
num++
fmt.Println("文本b：" + bb)
fmt.Println(a)
fmt.Println(num)


}


/*
多个变量的声明与赋值


全局变量的声明可使用 var() 的方式进行简写
全局变量的声明不可以省略 var，但可使用并行方式
所有变量都可以使用类型推断
局部变量不可以使用 var() 的方式简写，只能使用并行方式


*/


var (
aaa = "hello"
//并行赋值与类型推断
sss, ccc = 1, 2


//不可省略var
//dd:=3
)


/*
变量的类型转换


Go中不存在隐式转换，所有类型转换必须显式声明
转换只能发生在两种相互兼容的类型之间
类型转换的格式：
<ValueA> [:]= <TypeOfValueA>(<ValueB>)


结果:1
*/
func TypeChange() {
var num float32 = 1.1
b := int(num)


fmt.Println(b)


//无法通过编译
//var cc bool = false
//d := int(cc)
}


/*
int转string
结果：A
*/
func ItS() {
var a int = 65
b := string(a)
fmt.Println(b)
}


//不同类型整数不能直接比较
func Type_Change() {


var i int32
var j int64


i, j = 1, 2


// if i == j {
// fmt.Println("变量类型不同编译不通过.")
// }


if i == 1 || j == 2 {
fmt.Println("变量和常数比较编译通过.")
}
}


//浮点不是精确表达方式,所以==不能判断2浮点是否相等
/**
 * 判断2个float64数是否相等
 * @param f1
 * @param f2
 * return：真true,假false
 */
func FloatEquals(f1, f2 float64) bool {


flag := math.Nextafter(f1, f2) == f1
return flag
}


/*
复数
*/
func Plural() {


var value1 complex64


value1 = 3.2 + 12i
value2 := 3.2 + 12i
value3 := complex(3.2, 12)


fmt.Println(value1)
fmt.Println(value2)
fmt.Println(value3)
fmt.Println(real(value1), imag(value1)) //复数的实数部分和虚数部分


}


//字符串
func Gstring() {


var str string = "abcdefghijklmn"


s1 := str[0]
fmt.Println(string(s1))


var size int = len(str)
//循环打印字符串
for i := 0; i < size; i++ {
fmt.Print(string(str[i]))
}
//range便捷遍历集合中元素,i,v 返回元素下标和值
fmt.Println("range遍历")
//for _, v := range str { 下划线表示不使用下标i这个值
for i, v := range str {
fmt.Print(i)
fmt.Println(string(v))
}
}

---------------------

package part1


/*
go基础


1.包别名
2.函数大小写


时间：2013-11-07 14:28:04
*/


import (
"fmt"
"time"
)


//常量定义
const PI = 3.14


//全局变量声明赋值
var name = "john"


//一般类型声明
type newType int


//结构声明
type gopher struct{}


//接口声明
type golang interface{}


//显示当前时间,函数名大写代表public,小写代表private
func GetTime() {


fmt.Println(time.Now())
}


func fontMin() {
fmt.Println("函数名小写,代表private")
}


func FontMax() {
fmt.Println("函数名大写,代表public1")
}


//变量转换
func ChangeValue() {
var i, j int = 1, 2
fmt.Println("变量值交换前：", i, j)
i, j = j, i //变量值交换
fmt.Println("变量值交换后：", i, j)
}

------------------------

package main


import (
"fmt"
//包使用别名
bs "part1"


types "part2"
)


func main() {


bs.ChangeValue()
bs.GetTime()
// con.fontMin() 因为是方法名小写,所以包外无法引用
bs.FontMax()
types.Pri()
types.TypeChange()
types.ItS()
// flag := types.FloatEquals(1.1,1.1)
fmt.Println(types.FloatEquals(1.1, 1.1))


types.Plural()
types.Gstring()


types.ArrayBase()
types.PointerArray()
types.EqualsArray()
types.SetValue()
types.Dimensions()
unsort := [...]int{9, 5, 1, 17, 26, 38, 0, 0, 3}
types.BubbleSort(unsort)
types.ArrayUseParam()
}