go或称golang,google在2009年发布的一款新语言,而java上线时间是1995,java比go早14年,go比java好在哪里?对于 Java 来讲,Go语言拥有简明的类型系统、函数式编程范式和先进的并发编程模型。因此其代码块更小更简洁、可重用性更高,并可在多核计算环境下更快地运行。那既然这样,学习一下吧。
package main
import (
"container/list"
"container/ring"
"fmt"
"math"
"math/rand"
"sort"
"strconv"
"strings"
time2 "time"
)
func main() {
//fmt.Println("hello,world!")
//scanTest()
//defineVar()
//operator()
//testStr()
//testSentence()
//testTime()
//testMathAndRand()
//testArr()
//testMap()
//testList()
//testCircleList()
/**
*测试函数定义
*/
//testNoArgNoReturn()
//var a=testNoArgReturn()
//fmt.Println(a)
//testArgNoReturn("andy",18)
//b:=testArgAndReturn("jackay",18)
//fmt.Println(b)
//c,d:=testArgAndMoreReturn("lily",16)
//fmt.Println(c,d)
//fmt.Println(add(1,2))
//testVaryParams("a1","b2","c3")
//testAnonymousFunc()
//testFuncVary()
testImport()
}
/**
接收输入Scan
*/
func scanTest() {
var name, age string
fmt.Println("请输入姓名和年龄!")
//输入后换行
//fmt.Scanln(&name, &age)
//输入一个字符后换行再接收另外一个字符
fmt.Scanf("%s \n %s", &name, &age)
fmt.Println("接收到的内容为", name, age)
}
/**
变量定义测试
*/
func defineVar() {
//声明变量再赋值
var a string
a = "hello,world"
fmt.Println(a)
//声明变量直接赋值
var b string = "haha"
fmt.Println(b)
//声明变量直接赋值,可以去除类型
var c = "你好!"
fmt.Println(c)
var d = 123
//d = "test" //go是静态类型语言,已经设置为int,不能再改成string
fmt.Println(d)
//短变量,只能放在函数体内,不能定义成全局变量
e := "hi"
fmt.Println(e)
//一次声明多个变量
var f, g, h int
f, g, h = 1, 2, 3
fmt.Println(f, g, h)
//一次声明多个变量且赋值
var i, j, k = 6, 7, true
fmt.Println(i, j, k)
//使用var声明并赋值
var (
l = 8
m = 9
n = "net"
)
fmt.Println(l, m, n)
var z, z1, f1 = 0x795D, 0x5FD7, 0x98DE
//Println直接换行输出是int数字
fmt.Println(z, z1, f1)
//Printf输出格式化,%表示转义,%c表示转成字符
fmt.Printf("%c%c%c", z, z1, f1)
var o = 1.23
fmt.Println(o)
var f3 float64 = 1234567890
fmt.Println(f3)
//float64转int
fmt.Println(int(f3))
var f4 = 1234
//int转float64
var f5 = float64(f4)
fmt.Println(f5)
//bool赋值
var t1 bool = true
var f2 = false
fmt.Println(t1, "\n", f2)
//通过运算得到bool值
a2 := 5 > 3
fmt.Println(a2)
fmt.Printf("%T", a2)
var strTest = "\n hello,\t world!"
fmt.Println(strTest)
var strTest1 = `hello,\t world!`
fmt.Println(strTest1)
var str2, e1 = strconv.ParseInt("11", 10, 64)
fmt.Println(e1)
fmt.Println(str2)
}
/**
运算符
*/
func operator() {
//算数运算符
//+ - * / ++ -- %
var a, b, c = -1, 2, 3
fmt.Println(a + b*c)
fmt.Println(a + b/c)
c++
fmt.Println(c)
c--
fmt.Println(c)
//取模%
var d = b % c
fmt.Println(d)
var e = c % b
fmt.Println(e)
//比较运算符< > >= <= == !=
fmt.Println(a > b)
fmt.Println(a != b)
//逻辑运算符 && || !
var f = false
var g = true
fmt.Println(f && g)
fmt.Println(f || g)
fmt.Println(!f)
//赋值运算符 = += -= *= /= %= <<= >>= &= |= ^=
a += b
fmt.Println(a)
a *= b
fmt.Println(a)
a %= b
fmt.Println(a)
a <<= b
fmt.Println(a)
c &= b
fmt.Println(c)
//位运算符<< >> | & ^ &^ 通过补码进行运算
//a1补码11111111 b1补码00000010
var a1 = -1
var b1 = 2
fmt.Println(a1 | b1) //11111111->11111110->00000001
fmt.Println(a1 & b1) //00000010
fmt.Println(a1 ^ b1)
fmt.Println(a1 &^ b1)
}
/**
string类型测试
*/
func testStr() {
var str string = "hello,world"
fmt.Println(str)
//工具类strconv 字符串转换
var a string = "123"
var i, e = strconv.ParseInt(a, 10, 64)
if e == nil {
fmt.Println(i)
fmt.Printf("%T", i)
fmt.Println()
}
f := "1.5"
var f1, e2 = strconv.ParseFloat(f, 64)
if e2 == nil {
fmt.Println(f1 + 5)
}
//Atoi是ParseInt(s, 10, 0)的简写。
var j, e1 = strconv.Atoi(a)
if e1 == nil {
fmt.Println(j)
fmt.Printf("%T", j)
fmt.Println()
}
//转换成string
var b int = 12
var s string = strconv.FormatInt(int64(b), 10)
fmt.Println(s)
//Itoa是FormatInt(i, 10) 的简写。
var s1 string = strconv.Itoa(b)
fmt.Println(s1)
var s2 = "testa好 "
fmt.Println(len(s2))
//工具类strings
fmt.Println(strings.HasPrefix(s2, "test"))
fmt.Println(strings.Index(s2, "a"))
fmt.Println(strings.ToUpper(s2))
fmt.Println(strings.Replace(s2, "t", "a", -1))
fmt.Println(strings.Trim(s2, " "))
fmt.Println(strings.TrimSpace(s2))
arr := strings.Split(s2, "t")
fmt.Println(arr)
fmt.Printf("%T", arr)
arr1 := []string{"a", "b", "c"}
fmt.Println(strings.Join(arr1, "$"))
//常量定义 const
const c1 = "very good!"
fmt.Println(c1)
const (
c2 = 1
c3 = "sh"
c4 = true
)
fmt.Println(c2)
fmt.Println(c3)
fmt.Println(c4)
const (
c5 = 5
c6 = iota
c7
)
fmt.Println(c5, c6, c7)
//获取变量内存地址
var c8 = "aha"
fmt.Println(&c8)
//定义指针变量
var c9 *int
var c10 = 123
c9 = &c10
fmt.Println(c9, &c10)
fmt.Println(*c9, c10)
*c9 = 123456
fmt.Println(*c9, c10)
//new定义指针,c11不会为nil,c12不是new不能直接赋值需要先赋地址
var c11 = new(int)
var c12 *string
fmt.Println(c11)
fmt.Println(c12)
*c11 = 888888
fmt.Println(*c11)
*c12 = "test"
}
//测试go语句
func testSentence() {
//1.if else
score := 97
if score > 90 {
println("great")
} else {
println("need work hard")
}
//小括号也可以不加
if score > 90 {
println("great1")
}
if score > 60 && score < 90 {
println("中等")
}
//2.switch选择
var case1 = 9
switch case1 {
//可以指定多个
case 5, 8:
println("it is 5 or 8")
case 6:
println("it is 6")
//fallthrough穿透,可以继续执行 case 9,fallthrough不能放在最后一个case
fallthrough
case 9:
println("it is 9")
break //break退出,下面的语句将不会被执行
println("test break")
default:
println("nomatch default to do something")
}
//3.for循环
for i := 0; i < 10; i++ {
fmt.Println(i)
}
//内嵌循环,冒泡排序 >升序,<降序
var arr [5]int = [5]int{1, 8, 5, 9, 0}
var len = len(arr) - 1
for i := 0; i < len; i++ {
for j := 0; j < len-i; j++ {
if arr[j] > arr[j+1] {
arr[j], arr[j+1] = arr[j+1], arr[j]
}
}
}
fmt.Println(arr)
//4. continue 继续下次循环,break 退出当前循环
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if j == 2 {
continue
}
fmt.Println(i, j)
}
}
//定义标签
tag1:for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if j == 2 {
//可以对外面的循环生效
continue tag1
}
fmt.Println(i, j)
}
}
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if j == 1 {
break
}
fmt.Println(i, j)
}
}
//定义标签
tag2:for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if j == 2 {
//可以对外面的循环体生效
break tag2
}
fmt.Println(i, j)
}
}
//5.goto
a:=6
if a==6{
goto Label1
}
fmt.Println("test")
//定义了标签,goto之后会跳转到标签所在行开始执行, test打印语句将不会执行
Label1:
fmt.Println("this is Label1")
}
func testTime() {
//获取当前时间
var t = time2.Now()
fmt.Println(t)
//根据时间戳获得时间
var t1 = time2.Unix(0, t.UnixNano())
fmt.Println(t1)
//指定时间
t = time2.Date(2022, 7, 25, 10, 22, 12, 123, time2.Local)
fmt.Println(t)
fmt.Println(t.Year())
fmt.Println(t.YearDay())
fmt.Println(t.Hour())
//时间向string格式转换,2006-01-02 15:04:05 go的诞生时间,go不用yyyyMMdd这种格式
var str = t.Format("2006-01-02 15:04:05")
fmt.Println(str)
var str1 = t.Format("2006-01-02 15:04:05.000000")
fmt.Println(str1)
//string转换成时间
var str3 = "2022-01-01 08:08:08"
var t2, e = time2.Parse("2006-1-2 15:04:05", str3)
if e == nil {
fmt.Println(t2)
} else {
fmt.Println(e)
}
}
func testMathAndRand() {
//math
var f1 = 12.5
fmt.Println(math.Round(f1))
var f2 = 12.3
fmt.Println(math.Round(f2))
//rand
rand.Seed(time2.Now().UnixNano())
var r = rand.Intn(20000)
fmt.Println(r)
//假设取1000~9999之间的随机数
fmt.Println(1000 + rand.Intn(8999))
}
/**
数组
*/
func testArr() {
//完整定义 变量名 类型=[长度]类型{值}
var arr1 [3]int = [3]int{1, 2, 3}
fmt.Println(arr1)
//短变量
arr2 := [3]int{4, 5, 6}
fmt.Println(arr2)
//超过数组长度的,取默认值0
arr3 := [4]int{4, 5, 6}
fmt.Println(arr3)
//动态长度
arr4 := [...]string{"a", "b", "c"}
fmt.Println(arr4)
arr4[2] = "1"
fmt.Println(arr4)
fmt.Println(len(arr4))
//二维数组
var arr5 [3][2]int = [3][2]int{{1, 2}, {3, 4}, {5, 6}}
fmt.Println(arr5)
/**
*切片不设置数组长度,声明时不赋值不会分配内存空间
*切片是引用类型
*,数组不赋值也会事先分配内存空间
*/
fmt.Println("......切片测试......")
var slice1 []string
var arr0 [3]string
fmt.Println(slice1)
fmt.Println(len(slice1))//0
//打印类型
fmt.Printf("%T",slice1)
fmt.Println()
fmt.Println(arr0)
fmt.Println(len(arr0))//虽然没有赋值但是长度为3
//打印类型
fmt.Printf("%T",arr0)
fmt.Println()
//切片定义方法1
slice1=[]string{"a","b","c"}
fmt.Println(slice1)
arr0=[3]string{"1","2","3"}
fmt.Println(arr0)
//make可以创建slice,map,channel,interface,这里创建一个个数为6,容量为6的切片即数组
//切片定义方法2
var arr6=make([]int,6,6)
//查看数组长度和容量
fmt.Println(len(arr6),cap(arr6))
var arr7 [2]string=[2]string{"a","b"}
fmt.Println(arr7)
//动态新增
arr6=append(arr6,7)
fmt.Println(arr6)
//指定长度的数组不能append
//arr7=append(arr7,"c")
//新增一个其他切片,必须带上...
arr8 :=[]int{1,2,3}
arr6=append(arr6,arr8...)
fmt.Println(arr6)
//数组的一个片段也是切片,切片定义方法3
//切片是指针,简单说是没有定义长度的数组
var slice2=arr0[0:2]
fmt.Printf("%T \n",slice2)
fmt.Println(slice2)
//go 没有删除方法,只能通过append (]前包含后不包含的特性进行删除
var slice3 []string=[]string{"a","1","b","2","c","3"}
fmt.Println("slice3=",slice3)
var index=3//删除第四个元素
var slice4=slice3[0:index] //0~3 a,1,b,不包含2
var newSlice=append(slice4,slice3[index+1:]...)//从第5个元素,c开始
fmt.Println("slice3=",slice3)
fmt.Println("newSlice=",newSlice)
var s1=[]int{1,2}
var s2=[]int{7,5,1,9,8}
copy(s2,s1)//s1 copy到 s2,替换对应的元素
fmt.Println(s1)
fmt.Println(s2)
//采用copy方法删除元素、
//需要删除的索引
var n=3
//定义切片
var s3=make([]int,n)
//s2切片 copy到 s3
copy(s3,s2[0:n])
//s2剩余的append到s3
s3=append(s3,s2[n+1:]...)
fmt.Println(s3)
//sort排序
//升序
//sort.Ints(s2) 等同于下面
sort.Sort(sort.IntSlice(s2))
fmt.Println(s2)
//降序
sort.Sort(sort.Reverse(sort.IntSlice(s2)))
fmt.Println(s2)
}
func testMap() {
//没赋值时nil
var map1=make(map[string]string)
fmt.Println(map1)
var map2=map[string]string{"k1":"v1","k2":"v2","k3":"v3"}
fmt.Println(map2)
//key不存在则新增
map2["k6"]="v6"
//key存在则修改
map2["k3"]="value3"
fmt.Println(map2)
//删除
delete(map2,"k3")
fmt.Println(map2)
//如果k2存在,把值赋给val,是否存在的布尔值赋值给exist
val,exist:=map2["k2"]
fmt.Println(val,exist)
//循环map
for k,v:= range map2{
fmt.Println(k,v)
}
}
func testList(){
//新建双向链表
myList:=list.New()
fmt.Println(myList)
myList.PushBack("a")
myList.PushFront("1")
myList.PushBack("b")
//将a移到第一个
myList.InsertBefore("a",myList.Front())
//从第一个开始循环
for e:=myList.Front();e!=nil;e=e.Next(){
fmt.Println(e.Value)
}
//将第一个移到最后一个后面
myList.MoveAfter(myList.Front(),myList.Back())
fmt.Println(myList)
//从第一个开始循环
for e:=myList.Front();e!=nil;e=e.Next(){
fmt.Println(e.Value)
}
//取第三个元素值
n:=3
e:=myList.Front()
for i:=1;i<n;i++{
e=e.Next()
//fmt.Println(e.Value)
}
fmt.Println(e.Value)
}
/**
测试循环双向链接,双向链接头尾相连的特殊情况
*/
func testCircleList() {
r:=ring.New(6)
r.Value="a"//表示第一个元素赋值a
r.Next().Value="6"
r.Next().Next().Value="8"
r.Next().Next().Next().Value="9"
r.Prev().Value="5"
r.Prev().Prev().Value=1
//循环双向链表
r.Do(func(i interface{}) {
fmt.Println(i)
})
}
/**
函数测试
*/
func testNoArgNoReturn() {
fmt.Println("无参无返回值函数")
}
func testNoArgReturn()(int){
fmt.Println("无参有返回值函数")
return 123
}
func testArgNoReturn(name string,age int) {
fmt.Println("有参无返回值函数")
}
func testArgAndReturn(name string,age int) string{
fmt.Println("有参有返回值函数")
return name+","+strconv.Itoa(age)
}
func testArgAndMoreReturn(name string,age int) (string,int){
fmt.Println("有参有返回多值函数")
return name+","+strconv.Itoa(age),100
}
//也可以这么定义,直接赋值给返回值,那么返回就可以直接写return
func add(a int ,b int)(sum int) {
sum=a+b
return
}
func testVaryParams(params...string) {
for index,item:=range params{
fmt.Println(index,item)
fmt.Println(item)
}
}
func testAnonymousFunc() {
//匿名不带参数
func (){//不加方法名
fmt.Println("这么定义匿名函数")
}()//加上挂号表示调用
//匿名带参数
func(name string,age int){
fmt.Println(name+","+strconv.Itoa(age))
}("老祝",28)
//匿名带返回值
name:=func()string{
return "张三"
}()
fmt.Println(name)
//匿名带参带返回值
age:=func(age1 int)int{
return age1
}(18)
fmt.Println(age)
}
/**
定义函数变量
*/
func testFuncVary() {
var funcA func()
funcA= func() {
fmt.Println("函数变量定义")
}
funcA()
}
func testImport() {
//b:=stringutil.isempty("abc")
//fmt.Println(b)
fmt.Println("测试引用其他包名中的类")
}
package comm
func IsEmpty(param string) bool {
if param==""||len(param)==0 {
return true
}else {
return false
}
}