Go(3[切片])

切片:

• 切片底層都是數組

• 切片是一個指針類型,是數組的引用！

• 修改切片后的值，那原來的數據也會改變

• 傳輸數據大的時候,使用切片,節省內存，因為底層只是對數組的引用

• append操作的適合，如果長度超過設置的長度,那底層就會把底層元組進行擴容

• 切片里面可以放任何類型！！！

切片初始化:

    var b[]int = []int{1,2,3,4,5}

• 切片底層都是數組

• 切片是一個指針類型,應用類型，是數組的引用！！！

• 修改切片后的值,那原來的數據也會改變

• 如果傳輸的內容過大,介意用切片,節省內存

切片定義(代碼):

    切片是數組的引用,所以先創建一個數組

    var a [5]int

    var b[]int = a[0:2]       b是切片    

偽代碼定義:

    a[start:end]

示例

1. 示例一: 循環數組

1. 時刻記住go是強類型語言,變量后面需要指定類型
   

2. func Sum(a [100]int)int  {
      c:=0
      for i:=0;i<len(a);i++{
         c += a[i]
      }
      return c
   }

   
   

2. 示例二:循環切片

1. 其實與循環數組方式一樣

2. 需要注意是傳參的時候,需要把數組轉化為切片

1. var c[1000] int  轉化為切片就是 c[:]
   

3. func Sum2(a []int)int  {
      c:=0
      for i:=0;i<len(a);i++{
         c += a[i]
      }
      return c
   }

   
   

字符串切片:

//一個bytes占一個字節  一個字節是8位
//一個字符--》有可能占一個字節，或者三個字節
//一個中文，占3個字節

字符串底層是bytes的切片,   是用指針指向utf-8字節數組！！

字符串是只讀的！！,所以需要把字符串轉切片,然后在修改字符串,那就相當于開辟一塊新的內存空間

修改字符串，可將其轉化成【】rune或[]bytes ，完成后在轉化為string ，無論哪種方式，都會重新分配內存，并復制字節數組

var str = "hello word"
//把字符串轉切片，然后在修改字符串
str1 := str[:]
fmt.Printf("%s\n",str1)
//單引號是代表一個字符
var b []byte = []byte(str)
//通過下標重新賦值
b[0] = 'a'
str2 := string(b)
fmt.Println(str2,len(b))

示例一:

func testRever()  {
   //英文反轉
   var str = "hello word"
   var b []byte = []byte(str)
   for i:=0;i< len(b) /2 ;i++{
      b[i] = b[len(b) -i -1]
      b[len(b) -i -1] = b[i]

   }
   str2 := string(b)
   fmt.Println(str2,len(b))
}

實例二:

中文操作:rune 

func testChina()  {
   //帶中文的反轉
   str :="Hi  我愛晨紅"
   //rune 可能占一個字節或者多個字節
   b :=[]rune(str)
   fmt.Println("testChina",len(str),len(b))
   for i:=0;i< len(b) /2 ;i++{
      b[i],b[len(b) -i -1] = b[len(b) -i -1],b[i]
   }
   str2 := string(b)
   fmt.Println("testChina",str2)
}

func testConetChine()  {
   //統計中文,和英文出現的次數
   str :="翟hello，worker"
   b :=[]rune(str)
   fmt.Println("testChina",len(str),len(b))
}

>>>>testChina 17 13

得出！！當統計類型為字符串的適合,它會把每個值都當成一個字節來統計

    轉換rune后,那統計rune后的值,長度就變化了

實例三:

func testConetChine()  {
   //統計中文,和英文出現的次數
   str :="哈哈哈哈測試,hello，worker"
   b :=[]rune(str)
   fmt.Println("testChina",len(b),len(str))

}

切片的創建:

1. 第一種定義方式:定義切片的時候.默認是空 nil

1. var a[]int
   a = append(a,1,2,3,7,8)
   fmt.Printf("%#v\n",a)

2. 第二種定義方式:用make的時候,切片內容默認都是0,底層是有數據的

1. a=make([]int,5)
   a = append(a,1,2,3,7,8)
   fmt.Printf("%#v\n",a)

• 切片只能用make來創建

• 底層還是數組,是make來創建的

• //容量擴容原理

• 示例:

• func testSliceCap()  {
  
     //a切片長度為5，容量為10，那底層數組長度就是10
     //那b 可以在a的基礎上擴容, 但是不能超容量10
     a := make([]int,5,10)
     a[4] = 100
     //容量是從1開始，所以現在 b:=a[1:3] 的容量是9
     b:=a[1:3]
     //b[9] = 100
  
     fmt.Printf("a=%#v\n",a)
     fmt.Printf("b=%#v\n",b)
     //cap 內置方法 求出切片的容量7
     fmt.Println(cap(a),cap(b))
  }

切片Copy:

    copy(目標切片,源切片) 

1. 打印內存地址參數:p

2. cap 切片容量

s1 :=[]int{1,2,3}
s2 :=make([]int,10)
copy(s2,s1)
fmt.Println("\n",s1)
fmt.Println("\n",s2,cap(s2))

>------
 [1 2 3]

 [1 2 3 0 0 0 0 0 0 0] 10

切片Append:

定義切片: s3 :=[]int{1,2,3}

s4:=append(s3,3,4,5,6)

數組 / 切片 中的 ... 使用

數組:

func testArray()  {
   var a [5]int = [5]int{1,3}
   fmt.Println(a)
   //數組的...  是系統內部幫你計算，當你不知道有多少個的時候,那就用...
   var c  = [...]int{1,3,4}
   fmt.Println(c)
}

切片:

2個切片的append

//... 就是展開切片的意思

a = make([]int,5)
var b[] = []int{1,3,6,10}
a = append(a,b...)