人生苦短，Let's Go !

疯狂的KK

发布于 2021-04-09 15:46:00

3920

发布于 2021-04-09 15:46:00

文章被收录于专栏：Java项目实战

学习网站推荐

studygolang.com

liwenzhou.com

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用

if判断语句 for循环

package main

import "fmt"

func main() {
  BREAKDEMO1:
for i := 0; i < 5; i++ {
for j := 0; j < 3; j++ {
if j == 2 {
// 设置退出标签
break BREAKDEMO1
      }
      fmt.Printf("%v-%v\n", i, j)
    }
  }
//  return
// 标签
//breakTag:  相当于java的GOTO语法
  fmt.Println("结束for循环")
}

如果跳出两层循环在退出标签处写breakTag，然后声明标签，break，continue等也可用标签跳出，虽不常用，但看起来dd的

99乘法表

package main

import "fmt"

//编写代码打印9*9乘法表。
func main() {
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
      fmt.Printf("%d * %d = %-2d  ", i, j, i*j)
    }
    fmt.Println()
  }
}

Array(数组)

数组是同一种数据类型元素的集合。数组大小不可变

1.基本语法

var 数组变量名 [元素数量]T

package main

import "fmt"

//数组
func main() {

var  testArray [3]int
var  numArray = [3]int{1,2}
var cityArray = [3]string{"北京","上海","深圳"}

   fmt.Println(testArray)
   fmt.Println(numArray)
   fmt.Println(cityArray)

}

2.编译器根据初始值的个数自行推断数组长度

var  testArray [3]int //初始化  空
var  numArray = [...]int{1,2}
var cityArray = [...]string{"北京","上海","深圳"}

3.索引赋值

 a :=[...]int{1: 1,3: 5}
 // var  numArray = [...]int{1,2}
  //var cityArray = [...]string{"北京","上海","深圳"}
   fmt.Println(a)

遍历数组

func main() {


//a :=[...]int{1: 1,3: 5}
// var  numArray = [...]int{1,2}
var a = [...]string{"北京","上海","深圳"}
   for i :=0 ; i<len(a);i++{
        fmt.Println(a[i])


     }
     for index,value :=range a{
        fmt.Println(index,value)
     }

二维数组

a:= [3][2]string{
    {"北京","上海"},
    {"天津","内蒙"},
    {"成都","重庆"},
}
fmt.Println(a)
fmt.Println(a[2][1])

二维数组的遍历

a:= [3][2]string{
    {"北京","上海"},
    {"天津","内蒙"},
    {"成都","重庆"},
}
for _, v1 := range a{
    for _, v2 := range v1{  
        fmt.Println("%s\t",v2)
    }
}

切片 slice

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。属于引用数据类型不能直接比较

基本语法

var name []T

切片底层还是数组

package main

import "fmt"

//数组
func main() {
var a = [3]int{1,2,3}//数组
var b = []int{1,2,3}//切片
  fmt.Println(a,b)
  fmt.Println(a,b)
//从数组得到切片
var  c []int
c = a[0:2]//右不包含 c[:] 从开始到结束
d := a[:2]

fmt.Println(c)
fmt.Println(d)
//切片的大小
fmt.Println(len(b))
//切片的容量  底层数组最大能放多少
x := [...]string{"北京","上海","深圳","西安"}
y := x[1:4]
fmt.Println(y)
fmt.Println(len(y))
fmt.Println(cap(y))//x 从1开始
//切片再切片  以上注释掉
var a = [5]int{1,2,3,4,5}//数组
// var b = []int{1,2,3}//切片

//切片再切片
s := a[1:3]  // s := a[low:high]
  fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
  s2 := s[3:4]  // 索引的上限是cap(s)而不是len(s)
  fmt.Printf("s2:%v len(s2):%v cap(s2):%v\n", s2, len(s2), cap(s2))
}

low则默认为0；省略了high则默认为切片操作数的长度

对于数组或字符串，如果0 <= low <= high <= len(a)，则索引合法，否则就会索引越界（out of range）。

切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

要检查切片是否为空，请始终使用len(s) == 0

 var a =[]int{}//切片
  fmt.Printf("a:%v  len:%d  cap:%d  ptr:%p\n",a,len(a),cap(a), &a)
  a= append(a,1)
  fmt.Printf("a:%v  len:%d   cap:%d  ptr:%p\n",a,len(a),cap(a), &a)
  a= append(a,1)
  fmt.Printf("a:%v len:%d   cap:%d  ptr:%p\n",a,len(a),cap(a), &a)
  a= append(a,1)
  fmt.Printf("a:%v  len:%d  cap:%d  ptr:%p\n",a,len(a),cap(a), &a)
  a= append(a,1)
  fmt.Printf("a:%v  len:%d cap:%d  ptr:%p\n",a,len(a),cap(a), &a)

注:语法非常严格，注意各种符号位

地址值指向一样

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-03-26，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

本文分享自赵KK日常技术记录微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

编程算法

登录后参与评论

0 条评论

热度