go語言學習--基礎篇（3）

一，go語言數組

     1，數組的特色

　         a. 數組在初始化完成以後，數組的長度是固定的

             b. 只存儲同一類型的數據

             c. 數組中的元素與元素之間的內存空間是連續的

      2，數組的定義

             var a [5]int     其中a 表示數組的名稱，[5]表示數組的長度，int 表示數組中的元素類型

      3，數組中元素的訪問

              使用下標訪問 a[0],a[1],a[2]

      4，循環獲取數組每一個元素的地址

package main

import (

       "fmt"
)

func main() {

       var a [10]int
       for i :=0;i <10; i++{
             fmt.Printf("%p\n", &a[i]}

    }
}


輸出結果：                                        #明顯每一個元素佔8個字節，並且是連續的
0xc04206e050                                    #int 類型所佔的內存空間和操做系統有關 64位操做系統，int 佔64位，即8個字節
0xc04206e058                                     
0xc04206e060
0xc04206e068
0xc04206e070
0xc04206e078
0xc04206e080
0xc04206e088
0xc04206e090
0xc04206e098

        5，數組長度

             var  a[10]int   length := len(a)

         6，數組存在越界問題

              var  a[10]int 長度爲10，下標範圍爲0到9。訪問0到9以外的小標會報錯

         7，數組的遍歷

/* range 遍歷數組 */
package main
import (
	"fmt"
)
func main() {

	var a [10]int
	for index,val := range a{
		fmt.Printf("a[%d] = %d\n",index,val)
	}
}

 

           8， 值類型

func test() {

     var a [5]int = [5]int {1,2,3,4,5}
     var b [5]int
     b = a
     fmt.Printf("b=%v\n",b)
     b[0] = 200     
     fmt.Printf("b=%v\n",b)
     fmt.Printf("a=%v\n",a)
}

#輸出結果爲
#b=[1 2 3 4 5]
#b=[200 2 3 4 5]
#a=[1 2 3 4 5]
#從中能夠看出改變數組b中的元素，並不會改變數組a中的元素，這就是值類型

        9，數組的初始化

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

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

              c. var a = [...]int{1,2,3,4,5}  其中[...]表示不肯定長度

              d. var a = [5]string{1:"abc",2"eft"}  表示給數組a的前兩個元素賦值爲a[0]=abc,a[1]=eft

      10，二維數組定義

              var a[8][2]int   定義一個8行2列的數組

 

二，切片

     切片的長度是動態的,任何切片底層都爲數組

      1，切片的定義, 與數組的定義惟一的區別就是沒有長度，而且默認長度爲0

            var  變量名 [ ] type

           a. var  a [] string

           b. var  a [] float32

      2，切片的初始化（切片爲引用類型）

           var  a [5] int

           var  b []int = a [0:2]

           var  b []int = a [2:]

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

     3，示例思考

         能夠看出a 的值改變，相應的切片b的值也會變，說明切片爲指針類型或者引用類型

package main

import(
	"fmt"
)

func main(){

	var a [5]int
	b :=a[1:3]
	a[0] =100
	a[1] =200
	fmt.Printf("b:%#v\n",b)                         
}

輸出爲：
b:[]int{200,0}

          4，切片的內存佈局

               x 爲一個切片，切片的形式包含三個內容，指向底層數組的指針，定義切片的長度和切片的容量

           5，傳數組與傳切片

package main

import (
	"fmt"
)

func Sum(b []int){
	b[0] = 100
}

func SumArry(b [100]int){
	b[0] = 100
}

func main(){

	var a [100]int
	a[0] = 1
	a[1] = 2
	a[2] = 3

	Sum(a[:])
	fmt.Printf("a:%d\n",a[0])
	a[0] = 1                                                #重置a[0]的值
	SumArry(a)
	fmt.Printf("a:%d\n",a[0])
}

#輸出爲                                  
#a:100
#a:1
#從輸出結果能夠看出 傳入參數爲切片時，底層數組的值能夠被改變，當傳入是數組時，數組的值不能改變，#再次說明切片爲指針類型或者引用類型，而數組爲數值類型

           6，切片的建立

            var  b []int

            b = make([]int,5,10)

            a. 指定切片容量 make([]type，len，cap)

            b. 不指定切片容量，容量就等於長度 make([]type,len),

            注意：

                  以make 方式建立一個數組，其底層也一個數組，有make 建立

           

            7，切片的內存操做copy 和 append 操做，append 會對切片進行擴容，增長內存

            將一個切片append 到另外一個切片 

func testAppend(){
         var a []int
         a = make([]int,5)
         var b[]int = []int{10,11,12,14}
         a =append(a,b...)                       #b... 展開切片b的全部元素
         ftm.Printf("a:%#v\n",a)
}

 

          8，字符串的內存佈局

           在go 語言中，字符串也是一個切片，內存佈局以下圖

            a，ptr 爲指針

            b，len爲長度，

            c，容量也就是長度

            d，類型爲byte

  

          9，修改字符串中某個字符

func testStrSlice() {
          var str = 'hello world"
          var b []byte = []byte(str)                   #請字符串轉化成切片
          b[0] = 'a'                                         #修改切片第一個值
          str1 :=string(b)                                 #將切片轉化成string
          fmt.Printf("str1:%s\n",str1
}