go语言学习(数组,切片,字符串)

字符串

如果里面存储的是汉字,那么其实就是存储的是UTF--8编码,所以一个字会对应多个字节.如果想要获取汉字的个数,可以使用rune,来处理unicode字符

length:= utf8.RuneCountInString( s)

如果只使用len()获取的是字节的个数,

字符串的功能

1,获取字节长度 len(xx)

2,获取字符长度 utf8.RuneCountInString( xx)

3,以什么什么开头

var flag bool = strings.HasPrefix(检查串,目标串)

4,以什么什么结尾

var flag bool = strings.HasSuffix(检查串,目标串)

5,是否包含什么什么

var flag bool = strings.Contains(检查串,目标串)

6,变成全大写

str := strings.ToUpper(目标串)

7,变小写

str := strings.ToLower(目标串)

8,去除左边/右边的xxx

res:= strings.TrimRight(待去除串,去除部分)//去掉右边的 xxx

res:= strings.TrimLeft(待去除串,去除部分)//去掉左边的 xxx

res:= strings.Trim(待去除串,去除部分)//去掉两边的 xxx

如果两端有才去除,没有则不去除

9,替换

str := strings.Replace(字符串,待替换部分,替换成,从左到右第几个)

如果是-1 ,那就是全部替换

10,分割

str:=strings.Split(字符串,需要分割的依据)

比如:

s:="ababababababababa",

strs:=strings.Split(s,b)

strs就变成了a,a,a,a,a,a,a,a,a

11,拼接

s1+s2

//第一种方法  ,但是比较慢

list := []string (s1,s2)

s:= strings.Join(list,[可以自己选择中间的连接词])

//第二章方法,使用切片的内置函数来拼接

var a strings.Builder

a.writeString(s1)

a.writeString(s2)

s:=a.String()

12,string to int

var num int = strconv.Itoa(s)

13,int to string

var str string = strconv.Atoi(num)

14,进制转化为整型

func ParseInt(s string, base int, bitSize int) (i int64, err error)

这里base是进制数,如果是0,那就根据前缀去转换,bitSize 就是转化过程中的int大小,最后都会返回int64

s := "0x1F"

res,_ = strconv.ParseInt(s,0,32)

15,整型转化为进制

func FormatInt(i int64, base int) string  

这里的 base 是要转化为 base进制

数组

var name [确定的长度] 元素类型

var nums [10] int

//第一种初始化方式 ,初始结果为0

var nums = [10] int { 1,2,3,4}

//第二种方法,前4个指定为,1,2,3,4 后面没有指定,为0

var nums = [10]int {0: 1, 3:10}

//第三种方法,指定了0和3位置的值

var nums = [...] int {0: 1, 3: 100}

//第四种方法,省略长度,由系统推断,长度为 4

如果

var numsptr * [3] int  只是初始化了3个指针,但是指向的地点没有分配空间

numsptr := new ([3]int ) 这个就分配了空间

数组的内存是连续的,而且数组的内存地址就是num[0]的地址

数组的长度

var  n int = len(nums)

获取区间

subnums := nums [ start : end+1] //获取start 到 end 之间的所有元素

多维数组

var nums [2][3][4] int

//2个 3行4列的二维数组

这个数组可以直接用println打印

rune 是 int32 的别名，用于表示 Unicode 码点，方便按字符处理字符串。

切片

type slice struct {

        array unsafe.Pointer

        len int

        cap int

}

初始化:

var slice [] int  

//声明一个空的切片

var slice =[] int { 1,2,3}

//基于数组初始化了一个长度为3的切片

var slice = make ([] int ,2,5)

//基于make创建一个切片,第一个是表示类型,第二个是初始化长度,第三个是容量

//当然第三个可以缺省的,那样容量默认和长度一致

自动扩容:

每次都是扩容为当前容量的两倍,如果长度大于1024,每次只扩容1/4的大小

v1 := make ([]int,1,3)

v2 := append (v1,66)

//这里的v1和v2两个切片,但是对应存储的数组对应的是同一个,即共享同一个数组

//如果容量足够,就只是在后面添加一个新元素,如果容量不足,会直接扩容

//但是如果去获得他们的长度的话,一个是1,一个是2

append 也可以追加多个数字,也可以追加切片int []          {}

切片指针

var sp = new ([] int ) 

//创建一个指向长度为0,容量为0的以

var sp1 * [] int 

获取区间

res : = v1[start,end+1]   //获取start 到 end

res := v1[start]          //获取 start 到切片结尾

res := v1[:end+1]     //获取 开头 到 end

//这里也是共享的数组空间

v1 := [] int  {1,2,3,4,5,6}

res : = append(v1[:2],v1[3:])

//res 会 获得 1,2,4,5,6,

//v1也会变成这个