var name [size] type
// 如果数组长度不确定,可以使用 ... 代替数组的长度,
// 编译器会根据元素个数自行推断数组的长度:
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
name := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
// 1. 方式一:完整写法
var arr [3]int = [3]int{1, 2, 3}
// 2. 方式二:短变量方式(常用)
arr2 := [3]int{1, 2, 3}
// 3. 方式三:长度大于初始值个数.长度为4,只给前三个元素赋值,其余元素为默认值
arr3 := [4]int{1, 2, 3}
// 4. 方式四:赋值时不写长度,数组长度根据元素个数确定(常用)
arr4 := [...]int{1, 2, 3}
// 还可以通过指定下标来初始化元素
name := [...]float32{0:1000.0, 2:2.0, 3.4, 7.0, 50.0}
// 正常情况下 数组为值传递 即传递的是数组的值 在函数中对数组的操作 对于原数组无效。
func modify(array [5]int) {
fmt.Println (array) // [1 2 3 4 5]
array[0] = 10
fmt.Println(array) // [10 2 3 4 5]
}
func main() {
array := [5]int{1, 2, 3, 4, 5}
modify(array)
fmt.Println (array) // [1 2 3 4 5]
}
// 将数组结合指针作为参数传递 可以利用指针达到引用传递的效果
func modify(array *[5]int) {
fmt.Println(*array) // [1 2 3 4 5]
(*array)[0] = 10
fmt.Println(*array) // [10 2 3 4 5]
}
func main() {
array := [5]int{1, 2, 3, 4, 5}
modify(&array)
fmt.Println(array) // [10 2 3 4 5]
}
/*
数组练习:冒泡排序
注意:
数组与切片的区别
*/
func main() {
arr := [6]int{2,1,0,4,8,6}
fmt.Println(BubbleSort(arr))
}
func BubbleSort(arr[6]int) [6]int {
for i := 0; i < len(arr); i++ {
for i1 := 0; i1 < len(arr)-i-1; i1++ {
if arr[i1]<arr[i1+1] {
continue
}else {
arr[i1],arr[i1+1] = arr[i1+1],arr[i1]
}
}
}
return arr
}
二维数组表示一个数组变量中每个元素又是一个一维数组变量,跟java一样 声明二维数组:
var name [n] [m]
// 使用和java一样 n为行 m为列
数组的声明与赋值:
// 1.方式一:完整写法
var arr [3][3]int = [3][3]int{{1,2,3},{4,5,6},{7,8,9},}
// 2.方式二:短变量方式(常用) 注意 这里每行后都要有个逗号
arr := [3][3]int{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
}
注意: golang中的二维数组和java不一样 java不可以直接打印二维数组 但是go可以。
所谓的指针就是一个地址 而*指针 就相当于操作指针指向的那段地址的内存。
使用var变量名 *类型、 声明指针类型变量 【声明格式】 *var name type *号用于指定变量是作为一个指针。
func main() {
// 声明一个指针变量
var a *int
b:=1
// 将指针指向变量b的内存地址
a=&b
*a = 2
fmt.Println(b) // 2
}
使用new函数去创建指针, 使用new创建的指针是已经有指向的,所以可以直接通过 *指针 直接赋值; 而只声明的指针变量是不可以直接通过 *指针直接赋值的(野指针)。
new(type)会根据你给的type去开辟一个type大小空间 使指针指向这片空间,且不同于c语言 go语言的gc(垃圾回收)机制会自动释放这片空间。
【语法格式】 变量名 = new(type)
// 不同于直接声明指针,使用new(type) 声明的指针有一个默认的
var ptr01 *int
fmt.Printf("%p\n",ptr01) // 0x0
ptr02 := new(int)
fmt.Printf("%p\n",ptr02) // 0xc0000ac080
指针的默认值为 即:空指针
指针变量指向一个未知的空间 即为:野指针
// 空指针
var ptr01 *int
fmt.Println(ptr01) // nil
fmt.Printf("%p\n",ptr01) // 0x0
// 野指针: 指针变量指向一个未知的空间
*ptr01 = 1 // 会报错
通过指针间接操作(数组 切片 map 结构体)的方法
type Student struct {
id int
}
func main() {
// 与 数组
arr:=[3]int{1,2,3}
s:=&arr
// 方法一:(*变量名)[index]
fmt.Println( (*s)[0] )
// 方法二:变量名[index]
fmt.Println( s[0] )
// 与 结构体
student := Student{1}
i:=new(Student)
i = &student
i.id=2
fmt.Println(student) // 2
}
指针作为参数传递为 引用传递
func main() {
a := new(int)
*a = 1
test(a)
fmt.Println(*a)
}
func test(a *int) {
*a = 2
}
指针本身也是值,且这个值和 1
,2
一样,是不可以寻址的,这也是为什么 &(&a)
不行,但是 先b = &a
,再&b
却可以。
func main() {
s :=1
p:= &s
fmt.Println(a) // 变量的地址 0xc0000ac058
fmt.Printf("%p",&p) // 一级指针的地址 0xc0000d8018
pp:=&p
fmt.Printf("%T\n",p) // *int 一级指针:指向变量的地址
fmt.Printf("%T\n",pp) // **int 二级指针:指向一级指针的地址
}
通过二级指针 修改一级指针和变量的值
func main() {
s := 1
p := &s
s1 := 2
pp := &p
*pp = &s1 // 相当于将一级指针的指向 从s 改成了 s1
fmt.Println(*p) // 2
**pp = 100 // 直接修改变量的值
fmt.Println(s1) // 100
}
1. 切片的英文名称 slice
2. 切片:具有 可变长度 **相同类型**元素序列.
3. 由于长度是可变,可以解决数组长度在数据个数不确定情况下浪费内存的问题.
4. 切片和数组声明时语法最主要的区别就是长度
5. 切片只声明时为nil,没有开辟内存空间,不能直接操作切片,需要先初始化
注意:切片只能和nil进行判断是否相等
var s1 []int //声明切片和声明array一样,只是少了长度,此为空(nil)切片
s2 := []int{}
make 函数
s := make([]int,1,3)
fmt.Printf("%p",&s) // 0xc000004078
fmt.Println(len(s)) // 1
fmt.Println(cap(s)) // 3
// 长度和容量的不同
s := make([]int,0,3) // 此时有三个空位
s := make([]int,3,3) // 此时三个位置都是默认值 0
append 函数
s1 := make([]int, 0)
fmt.Println(s1) // []
fmt.Println(len(s1),cap(s1)) // 0 0
// 一次 添加多个值,且添加后的长度大于扩容一次的大小,会导致容量和长度相等.
s1 = append(s1,2,3,4)
fmt.Println(s1) // [2,3,4]
fmt.Println(len(s1),cap(s1)) //3 3
// 等到下次添加内容时如果不超出扩容大小(就是原容量*2), 在现在的基础上进行翻倍。
s1 = append(s1,5)
fmt.Println(s1) //[2 3 4 5]
fmt.Println(len(s1),cap(s1)) //4 6
// 向切片中添加的也是个切片
a:=make([]string,0)
b:=make([]string,1,3)
b = append(b, "伤病","大傻逼")
a = append(b,b[1:]...)
fmt.Println(a) // [ 伤病 大傻逼 伤病 大傻逼]
通过数组产生切片
slice := [] int {1,23,4,5}
// 1.如果增加后切片的长度没有超出数组,修改切片也是在修改数组(即和原数组指向同一个地址)
sb := [...]int{1,2,3,4,5}
s :=sb[0:]
s[0]=3
fmt.Println(sb) // [3 2 3 4 5]
// 2. 如果增加后切片的长度超出数组,会重新开辟一块空间放切片的内容
sb := [...]int{1,2,3,4,5}
s :=sb[0:]
fmt.Printf("%p\n",&sb) //0xc00000c2a0
s = append(s,1,3,4)
fmt.Println(sb) // [1 2 3 4 5]
fmt.Println(s) // [1 2 3 4 5 1 3 4]
fmt.Printf("%p\n",&s) // 0xc000004078
Go语言标准库中没有提供删除的函数
切片也可以取其中的一段形成子切片,利用这个特性可以实现删除效果(会导致原来的内容也随之改变 所以删除的话就不要使用内容了)
slice := [5]int {1,2,3,4,5}
n:= 2
newSlice := slice[0:n]
newSlice = append(newSlice, slice[n+1:]...)
fmt.Println(newSlice) // [1 2 4 5]
newSlice[0]=8888
// 会导致原来的内容也随之改变 所以删除的话就不要使用内容了
fmt.Println(slice) // [8888 2 4 5 5]
g:=[]int{1,2,3,4,5,6}
n := 2 //要删除元素的索引
newSlice := make([]int,n)
copy(newSlice,g[0:n])
newSlice = append(newSlice,g[n+1:]...)
fmt.Println(g) // [1 2 3 4 5 6]
fmt.Println(newSlice) // [1 2 4 5 6]
// 1. 正常冒泡排序
func main() {
arr:=[]int{1,234,5,1,52,2,4}
BubbleSort(arr)
}
func BubbleSort(arr[]int) {
for i := 0; i < len(arr); i++ {
for i1 := 0; i1 < len(arr)-i-1; i1++ {
if arr[i1]<arr[i1+1] {
continue
}else {
arr[i1],arr[i1+1] = arr[i1+1],arr[i1]
}
}
}
fmt.Println(arr) // [1 1 2 4 5 52 234]
}
// 切片作为参数传递为引用传递,函数对切片的操作,同样也作用与原切片。
// 切片本身就是个引用变量 是一个指向某片内存的地址
func modify(array []int) {
fmt.Println(array) // [1 2 3 4 5]
array[0] = 10
fmt.Println(array) // [10 2 3 4 5]
}
func main() {
array := []int{1, 2, 3, 4, 5}
modify(array)
fmt.Println(array) // [10 2 3 4 5]
}
注意:使用append添加元素,容量足够,则在原基础之上添加数据,地址不会发生改变,容量如果不够,就会重新开辟一片空间。
a:=[]int{1,3,4}
s:=a
s = append(s, 1,2,3,4,5,6)
fmt.Printf("%p\n",a) // 0xc000012168
fmt.Println(a) // [1 3 4]
fmt.Printf("%p\n",s) // 0xc0000160f0
fmt.Println(s) // [1 3 4 1 2 3 4 5 6]
//-------------------------------------------
b:=make([]int,0,3)
b = append(b, 1,2,3)
s:=b
s[0]=888
fmt.Printf("%p\n",b) // 0xc000012168
fmt.Println(b) // [888 2 3]
fmt.Printf("%p\n",s) // 0xc000012168
fmt.Println(s) // [888 2 3]
map以散列表方式存储键值对集合
map中每个元素都是键值对
声明格式: map [键的类型] 值的类型{key:value,key:value}
key是操作map的唯一标准可以通过key对map中元素进行增加/删除/修改/查看
key是唯一的,添加重 复的key会覆盖之前的元素.
map是 引用类型 (不是值类型,目前学到的引用类型就是切片和map),只声明时为空指针(nil)
map读写数据时并不是并发安全的,可以结合RWMutex保证并发安全(RWMutex在后面讲解)
fmt.Println(map01) // map[名称:单冰 年龄:123]
map01["名称"]= "傻逼"
fmt.Println(map01) // map[名称:傻逼 年龄:123]
使用make函数 ap01:= make(map[int]int)
可以在声明map时直接给map赋初始值.注意初始值在一行和在多行写时的语法区别 := map[int]int{1:2,2:3}
map中元素键值对语法满足: key:value
key和value的类型必须和map[key]value类型严格对应
map01 := make(map[int]string)
map02 := map[string]string{"年龄":"123","名称":"单冰"}
使用key判断,如果key不存在向map中新增数据,如果key存在会覆盖map中元素
Go语言标准库中提供了对map元素删除的函数,使用顶层delete()即可完成删除 如果key存在,执行删除元素 如果key不存在,map中内容不变,也不会有错误
map01 := map[int]int{1:1,2:2}
delete(map01, 1)
查看map中key对应的value 如果有 返回对应value 如果没有 返回对应类型的默认值
value,ok := s[3] 返回俩值 一个是key对应value 一个是该key是否存在
func main() {
map01 := make(map[int]int)
a,b:=map01[3]
fmt.Println(a,b) // 0 false
}
同切片一样 都是引用传递,函数中对map的操作就是对原map的操作。
func main() {
map01 := map[int]int{1:1,2:2}
modify(map01)
fmt.Println(map01)
}
func modify(m map[int]int) {
m[3] = 3
m[4] = 4
}
有时我们需要将不同类型的数据组合成一个有机的整体。
如:一个学生有学号/姓名/性别/年龄/地址等属性。
显然单独定义以上变量比较繁琐,数据不便于管理。
// 正常写法
var id int
var name string
var sex string
var age int
var addr string
// 使用结构体表示法
type Student struct {
id int
name string
sex string
age int
addr string
}
结构体是一种聚合的数据类型,它是由一系列具有相同类型或不同类型的数据构成的数据集合。
每个数据称为结构体的成员。
注意:结构体的定义是在主函数的外面的。
定义:
type 结构体名 struct {
(结构体成员列表) 成员名 数据类型
}
定义结构体变量:
var 变量名 结构体名
type Student struct {
id int
name string
sex string
age int
addr string
function func(int2 int) string
slice []int
arr [4]int
map01 map[int]int
}
注意:
初始化:
//1. 顺序初始化(每个成员必须初始化 且顺序要一致)
var stu1 Student = Student{1,"xxx","男",1,"地球"}
//2. 自动推导 和指定成员赋值 未赋值的成员为默认值
stu1 := Student{1,"xxx","男",1,"地球"}
stu1 := Student{name: "xxx",id: 1}
fmt.Println(stu1.name) // xxx
var stu1 Student
stu1.id = 1
stu1.name = "xxx"
注意:
结构体名默认指向的就是第一个成员的地址
var stu1 Student
stu1.id = 1
stu1.name = "xxx"
fmt.Printf("%p\n",&stu1) // 0xc00001e080
fmt.Printf("%p\n",&stu1.id) // 0xc00001e080
fmt.Printf("%p\n",&stu1.name) // 0xc0000dc008
类似于java中的 类 student类 可以有成员变量 也可以有成员方法 。
type Student struct {
id int
age int
}
func main() {
var stu01 Student
var stu02 Student
stu01.id=1
stu02.id=2
// 存放类型为结构体类型的数组、和 切片
var stuArr = [2]Student{
stu01,
stu02,
}
fmt.Println(stuArr)
var stuSli = []Student{
stu01,
stu02,
}
fmt.Println(stuSli)
var stuMap = map[int]Student{
1:stu01,
2:stu02,
}
fmt.Println(stuMap)
}
结构体作为函数参数传递的时候为值传递
type Student struct {
id int
age int
}
func main() {
var stu01 Student = Student{1,19}
test001(stu01)
fmt.Println(stu01) // {1 19}
}
func test001(student Student) {
student.age=333
}
Go语言对关键字的增加非常吝啬,其中没有private、 protected、 public这样的关键字。
要使某个符号对其他包(package)可见(即可以访问),需要将该符号定义为以大写字母开头。