数组
package main
import (
"fmt"
)
//数组：数组是同一类型元素的集合。可以放多个值，但是类型一致，内存中连续存储
// Go 语言中不允许混合不同类型的元素
func main() {
//1 数组的定义,数组的大小，在定义阶段就确定了，而且不能改
//定义了一个大小为3的string类型数组，里面可以放3个字符串
//var names [3]string
//var ages [3]int8
//fmt.Println(ages)
//2 数组赋值
//var ages [3]int8
//ages[0]=99
//ages[2]=88
//fmt.Println(ages)
//fmt.Println(ages[1])
//3 定义并初始化,
//var ages [3]int=[3]int{1,2,3}
//var ages [3]int=[3]int{1,2}
//var ages [3]int=[3]int{}
//var ages=[3]int{}
//ages:=[3]int{1,3,4,7} //不允许多放
//fmt.Println(ages)
//4 数组定义并初始化的其他（了解）数组只要定义，长度就固定了，。。。,后面放几个值，数组大小是多少
//var ages [9]int=[...]int{1,2,3,4,5,6,7,8} //不支持这个
//var ages =[...]int{1,2,3,4,5,6,7,8}
//ages :=[...]int{1,2,3,4,8}
//fmt.Println(len(ages))
//5 数组的大小是类型的一部分
//var a [2]int=[2]int{1,2}
//var b [2]int=[2]int{1,3}
//b=a //如果不是同一种类型，不允许相互赋值
//fmt.Println(b)
//6 数组是值类型
//var a [2]int=[2]int{1,2}
//fmt.Println(a)
//test5(a) //因为数组是值类型，go函数传参，都是copy传递，如果是值类型，函数内改了，不会影响原来的
//fmt.Println(a)
//7 数组长度 len() 数组长度在定义阶段已经固定
//var a [2]int=[2]int{1,2}
//fmt.Println(len(a))
//8 数组循环
//var a =[...]int{7,4,3,5,6,7}
//fmt.Println(a[99])
//fmt.Println(len(a))
//普通循环
//for i:=0;i<len(a);i++{
// fmt.Println(a[i])
//}
//通过range来循环 (range不是内置函数，是一个关键字，for，if，else),打印出索引
//for i:=range a{
// fmt.Println(i)
//}
//如果用一个变量来接收，这个值是可迭代的索引
//如果用两个变量来接收，这两个变量，一个是索引，一个具体的值
//for i,value:=range a{
// fmt.Println(i)
// fmt.Println(value)
//}
//把数组循环打印出来
//for _,value:=range a{
// fmt.Println(value)
//}
// 9 多维数组
//var a [3][3]int //定义
//a[0][1]=99 //使用
//fmt.Println(a)
//定义并赋初值
//var a [3][3]int=[3][3]int{{1},{1,2,3},{4,4,4}}
//var s =[3][3]string{{"lqz","xxx","yyy"},{},{}}
//fmt.Println(s)
//
////循环多维数组
//for _,value:=range s{
// for _,in_value:=range value{
// fmt.Println(in_value)
// }
//}
//10 数组定义并指定位置初始化
//var names [100]int=[100]int{10:99,99:99}
//var names [100]int=[100]int{10,11,2,44,99:99,45:88}
//fmt.Println(names)
}
func test5(a [2]int) {
a[0]=99
fmt.Println(a)
}
切片
package main
import "fmt"
//切片:可以变长，
//切片是对底层数组的引用
//切片的改变会影响底层数组
//底层数组的改变，会影响切片
//切片的追加可能会触发扩容，一旦扩容，就不再依赖于原来的底层数组了
func main() {
//var a []int
//var b [3]int
//fmt.Printf("%T",a)
//fmt.Println()
//fmt.Printf("%T",b)
//切片的初始化，从数组切出来
//var a [10]int
//b是切片
//b:=a[:]
//var b []int=a[:] //从开头切到结尾，赋值给切片b
//fmt.Println(b)
//fmt.Printf("%T",b)
//切片的修改
//b[0]=99
//a[0]=888
//fmt.Println("b-----",b)
//fmt.Println("a-----",a)
//切片的长度和容量
//var a [10]int
////var b []int=a[3:]
//var b []int=a[3:6]
////a[3]=999
//b[2]=222
////fmt.Println(a)
//fmt.Println(b)
//fmt.Println(len(b)) //3
//fmt.Println(cap(b)) //7
//b[3]=999 //不可以 index out of range [3] with length 3
//var c []int=a[8:]
//fmt.Println(len(c)) //3
//fmt.Println(cap(c))
//切片定义的第二种方式，通过make创建
//创建了一个长度为2，容量为4的切片
//var a []int=make([]int,2,4)
//等同于
//b:=[4]int{0,0,0,0}
//a:=b[0:2]
//fmt.Println(len(a))
//fmt.Println(cap(a))
//创建了一个长度为2，容量为2的切片
//var a []int=make([]int,2)
//fmt.Println(len(a))
//fmt.Println(cap(a))
//扩容，追加切片
//var a []int=make([]int,2,4)
//a[0]=111
//a[1]=222
//fmt.Println(a)
////使用内置函数append
//a=append(a,333,444)
//fmt.Println(a)
//fmt.Println(len(a))
//fmt.Println(cap(a))
//临界点到了
//a=append(a,555)
//fmt.Println(a) //111 222 333 444 555
//fmt.Println(len(a)) //5
//fmt.Println(cap(a)) //8,自动扩容，在原来容量的基础上扩一倍
////切片超过了最大容量，底层数组重新创建，重新指向新的数组
//a=append(a,666,777,888,999)
//fmt.Println(a) //
//fmt.Println(len(a)) //9
//fmt.Println(cap(a)) //16
//切片超过了最大容量，底层数组重新创建，重新指向新的数组
//var a [10]int
//b:=a[8:]
//fmt.Println(b)
//fmt.Println(len(b))
//fmt.Println(cap(b))
//a[9]=999
//fmt.Println(a)
//fmt.Println(b)
//b[0]=888
//b=append(b,666)
//fmt.Println("aaaa",a)
//
//fmt.Println("------")
//fmt.Println(b)
//fmt.Println(len(b))
//fmt.Println(cap(b))
////改掉数组的最后一个值
//a[9]=1234
//fmt.Println(b)
//b[0]=666
//fmt.Println("----------------")
//fmt.Println(b)
//fmt.Println(a)
//切片的函数传递,切片是引用类型，引用类型的空值是nil
//所有引用类型的空置都是nil
//var a[]int=[]int{1,2,3}
////长度是3，容量是3
//fmt.Println(len(a))
//fmt.Println(cap(a))
////fmt.Println(a) //
//if a==nil{
// fmt.Println("空的")
//}else {
// fmt.Println("不是空")
//}
//var a[]int=[]int{1,2,3}
//test(a)
//fmt.Println(a) // 999 2 3 影响原来的
//多维切片
//var a [][]string=[][]string{{"lqz","egon"},{"zs"},{}}
//第一层的切片：长度是3 ，容量是3
//第二层的切片：不确定，根据初始化的情况判断
//fmt.Println(len(a[2]))
//fmt.Println(cap(a[2]))
//var a [][]string=make([][]string,3,4)
//fmt.Println(a)
//if a[2]==nil{
// fmt.Println("空")
//}
//a[2]=make([]string,3,4)
//fmt.Println(a[2][0])
//copy 内置函数
//var a [10000]int
//b:=a[:2]
//b[0]=111
//b[1]=222
//
//var c []int=make([]int,1,4)
////把b copy到c身上
//copy(c,b)
//fmt.Println(c)
var c []int=[]int{3,4,5,6,7,8,9,9}
//for i:=0;i<len(c);i++{
// fmt.Println(c[i])
//}
for _,v:=range c{
fmt.Println(v)
}
}
func test(a []int) {
a[0]=999
fmt.Println(a)// 999 2 3
a=append(a,777) //如果扩容了，以后再改的，不会影响原来的，如果没扩容，修改会影响原来的
fmt.Println(a) // 999 2 3 777
a[0]=444
fmt.Println(a)// 444 2 3 777
}
字符串
package main
//字符串
import (
"fmt"
)
//len字符串看到的是字节长度
func printBytes(s string) {
for i:= 0; i < len(s); i++ {
//fmt.Printf("%x ", s[i])
fmt.Println(s[i])
}
}
func main() {
//name := "Hello World"
//name := "中国"
////printBytes(name)
//runeLen(name)
}
func runeLen(s string) {
//字符长度
//res:=utf8.RuneCountInString(s)
//fmt.Println(res)
//for i:=0;i<utf8.RuneCountInString(s);i++{
// fmt.Println((s[i]))
//}
}
maps
package main
import "fmt"
//maps 字典,存储key value的的数据结构
func main() {
//1 定义
//int是key值类型，string是value类型
//引用类型，空值是nil
//var m map[int]string
//if m==nil{
// fmt.Println("空")
//}
//定义并初始化
//var m map[int]string= map[int]string{1:"lqz",2:"egon"}
//var m = map[int]string{1:"lqz",2:"egon"}
m:=map[int]string{199:"lqz",200:"egon"}
fmt.Println(m)
//添加元素
m[1]="zhangsan"
fmt.Println(m)
//获取元素
//fmt.Println(m[199])
//获取的元素不在map中，结果取决于value值的类型
//fmt.Println(m[2])
//m1:=map[int]int{1:1}
//fmt.Println(m1[2])
//判断元素是否再map中
//m1:=map[int]int{1:111}
////value是key对应的值，如果不存在，为value的空值
////flag 是个bool值，如果不存在，是false，如果存在是true
//value,flag:=m1[1]
//fmt.Println(value)
//fmt.Println(flag)
// 循环map （python字典有序？3.6以后有序了）
/*
python字典的底层结构：https://www.cnblogs.com/xiaoyuanqujing/articles/12008689.html
在Python 3.5（含）以前，字典是不能保证顺序的，键值对A先插入字典，键值对B后插入字典，但是当你打印字典的Keys列表时，你会发现B可能在A的前面。
但是从Python 3.6开始，字典是变成有顺序的了。你先插入键值对A，后插入键值对B，那么当你打印Keys列表的时候，你就会发现B在A的后面
[key,key,key]
*/
//go语言的map是无序的
//m1:=map[int]int{1:111,4:444,8:888}
//m1[5]=999
//m1[3]=888
//for k,v:=range m1{
// fmt.Println("k是",k,"v是",v)
//}
//删除元素
//m1:=map[int]int{1:111,4:444,8:888}
//delete(m1,4)
//fmt.Println(m1)
//map的长度
//fmt.Println(len(m1))
//fmt.Println(cap(m1))
//使用make初始化map,数字不用填，这个数字其实是底层数组的大小
//m2:=make(map[int]int)
//m2[1]=11
//m2[2]=222
//m2[3]=333
//m2[4]=444
//m2[5]=555
//fmt.Println(m2)
//map 是引用类型
//m2:=make(map[int]int)
//m2[1]=11
//m2[2]=222
//m2[3]=333
//m2[4]=444
//
//test6(m2)
//fmt.Println(m2)
//map 之间不能使用 == 操作符判断，== 只能用来检查 map 是否为 nil
//m2:=make(map[int]int)
//m2[1]=11
//
//m3:=make(map[int]int)
//m3[1]=11
//
////两个map之间不允许直接比较
//if m2==nil{
//
//}
}
func test6(m map[int]int) {
m[1]=999
}
指针
package main
import "fmt"
//指针：变量，存内存地址
//指针是一种存储变量内存地址的变量。
//取地址符号 & ，写在一个变量前，表示取该变量的地址
//* 放在类型前，表示该类型的指针
//* 放在变量前，表示解引用（取该地址对应的值）
func main() {
//var a int=10
////指针类型的变量
////b:= &a
//var b *int=&a
////fmt.Println(b)
//
////c:=&b
//var c **int=&b
//
//var d ***int=&c
//fmt.Println(d)
//
//fmt.Println(***d)
//指针的0值：<nil>，引用类型
//var a *int
//fmt.Println(a)
//指针的解引用
//s:="lqz"
////s_p:=&s
//var s_p *string=&s
//fmt.Println(*s_p)
//向函数传递指针参数
//var a =10
//test2(&a)
//fmt.Println(a)
//s:="lqz"
//test3(&s)
//fmt.Println(s)
//不要向函数传递数组的指针，而应该使用切片
//var a=[4]int{6,8,9} //6,8,9,0
//test4(&a) //取了数组的地址，传入了test4
//fmt.Println("-----",a)
//
//test5(a[:])
//fmt.Println("-----",a)
//指针不支持运算（c语言指针支持运算）
//var a =[3]int{9,7,6}
//b:=&a
////b++ //不支持
//fmt.Println(b)
// 指针数组和数组指针
var a *[3]int //指向数组的指针 指向这种数组的指针[3]int
a=&[3]int{1,2,43}
fmt.Println(a)
var b [3]*int //大小为3，内部放int类型的指针
a1,a2,a3:=10,20,30
b[0]=&a1
b[1]=&a2
b[2]=&a3
fmt.Println(b)
}
func test4(a *[4]int) {
//(*a)[0]=999 //解引用，改值
a[0]=999 //等同于上面，数组的指针不需要解引用再通过索引取值，直接通过索引取值即可
fmt.Println(a)
}
func test5(a []int) {
a[0]=999
fmt.Println(a)
}
func test2(a *int) {
fmt.Println(a)//地址
fmt.Println(*a) //解引用 10
*a=100
}
func test3(a *string) {
fmt.Println(*a)
*a="ssssss"
}
