初始化基本一樣，不同點需要注意，make使用，nil變量的訪問

array

初始化：

57 //修改元素值函數，指針版本和副本版本，指針版會修改原值

58 func modify(arr [3]int, i int, v int) {

59 //func modify(arr *[3]int, i int, v int) {

60 arr[i] = v

61 }

62

63 func main() {

64 var v [2]int //默認初始化為0

65 v1 := [2]int{} //默認初始化為0

66 v2 := [...]int{} //根據初始化列表決定元素個數，元素個數為0

67 v3 := [3]int{2: 99} //指定索引初始化

68

69 fmt.Println(v, v1, v2, v3)

70 }

slice

初始化：

71 //切片函數參數版本

72 func modify(arr []int, i int, v int) {

73 arr[i] = v

74 }

75

76 func main() {

77 //和數組區別在于是否指定元素個數，和數組一樣都是有長度的，所有隨機訪問時小心越界

78 var v []int //v == nil，nil值切片沒有底層數組

79 vv := []int(nil) //vv == nil，nil值切片沒有底層數組

80

81 v0 := []int{} //v != nil，nil切片和0長度切片行為一致，函數會等同對待

82 v1 := []int{1, 2}

83

84 var arr [3]int

85 v2 := arr[:]

86 v3 := arr[2:]

87

88 v3 = v1

89 modify(v3, 0, 111)

90 v2 = nil

91

92 v4 := make([]int, 3, 6) //若不指定cap，則和len一致

93

94 //v5 := make([]int, 4)

95 //v5 = v4[4:] //panic:slice bounds out of range，v4超過了len()

96 v4 = push(v4, 123)

97 v4 = push(v4, 123)

98 v4 = push(v4, 123)

99 v4 = push(v4, 123)

100

101 fmt.Println(v == nil, vv == nil, v0 == nil, v1, v2 == nil, v3, cap(v4), len(v4), v4)

102

103 }

數組可以用==進行比較，切片編譯錯誤

append簡單實現：

45 func push(s []int, v int) []int {

46 var tmp_s []int

47 if len(s) < cap(s) {

48 tmp_s = s[:(len(s) + 1)]

49 } else {

50 tmp_s = make([]int, len(s)+1, 2*len(s))

51 copy(tmp_s, s)

52 }

53

54 tmp_s[len(s)] = v

55

56 return tmp_s

57 }

copy函數，按照src,dst最小長度進行底層數組數據拷貝

?

appen使用：

105 v5 := make([]int, 2, 6)

106 v5 = append(v5, 1, 2)

107 v5 = append(v5, v4...)

append變長簡單實現：

76 func push_s(s []int, v ...int) []int {

77 var tmp = make([]int, len(s)+len(v))

78 copy(tmp, s)

79 copy(tmp[len(s):], v)

80

81 return tmp

82 }

slice內存技巧：

不用分配新空間，在原slice上修改

清理0數據

84 func RemoveInvalid2(s []int) []int {

85 i := 0

86 for _, v := range s {

87 if v != 0 {

88 s[i] = v

89 i++

90 }

91 }

92

93 return s[:i]

94 }

95

96 func RemoveInvalid(s []int) []int {

97 s_tmp := s[:0]

98 for _, v := range s {

99 if v != 0 {

100 s_tmp = append(s_tmp, v)

101 }

102 }

103

104 return s_tmp

105 }

107 func RemoveIndex(s []int, i int) []int {

108 if i >= len(s) {

109 return s

110 }

111 copy(s[i:], s[i+1:])

112 return s[:len(s)-1]

113 }

114

115 func Reverse(s []int) []int {

116 if len(s) < 2 {

117 return s

118 }

119 for i := range s {

120 if i >= (len(s) - i - 1) {

121 return s

122 }

123 s[i], s[len(s)-i-1] = s[len(s)-i-1], s[i]

124 }

125 return s

126 }

我們也看到了slice作為函數參數的使用，同樣map也是會作為引用來使用的，使用時要注意slice和map內部變化，防止得不到想要的結果，所以我一般會在函數返回后進行賦值

map

128 func insert(m map[int]string, i int, s string) map[int]string {

129 m[i] = s

130 return m

131 }

132

133 func main() {

134 var m map[int]string

135 m1 := map[int]string{2: "ss", 5: "aa"}

136 delete(m1, 5)

137

138 m2 := make(map[int]string)

139 m3 := map[int]string{}

140 m3 = insert(m3, 2, "aaaaaaa")

141

142 m4 := make(map[int]map[string]bool)

143 fmt.Println(m == nil, m1, m2, m3, m4)

144 }

注意：key必須是可比較的類型，如字符串，數組（可比較的字段），結構體（可比較的字段）

slice不能比較，但可以轉換成字符串再存儲為key

struct

149 type Point struct {

150 x, y float64

151 }

152

158

159 type line struct {

160 pt []Point

161 }

163 func main() {

164 /*

165 l := []struct {

166 pt []Point

167 cnt int

168 }{{

169 pt: []Point{{

170 x: 1,

171 y: 2,

172 }, {

173 x: 3,

174 y: 4,

175 }},

176 cnt: 2,

177 }}

178 */

179

180 var pt Point

181 pt.x = 1

182 pt.y = 2

183

184 pt1 := Point{1, 2} //這種初始化方式不推薦，建議用下方

185 pt2 := Point{x: 1, y: 2}

186

187 l := []line{}

188

189 var l1 line

190 //l1 := line{}

191

192 l = append(l, l1)

193 l[0].pt = append(l[0].pt, Point{11, 22})

194 fmt.Println(pt, pt1, pt2, l, l1)

195 }

結構方法使用

153 //func (p *Point) Distance(target *Point) float64 {

154 func (p Point) Distance(target *Point) float64 {

154 p.x = 0.1

155 target.x = 0.2

156 return 0.0

157 }

197 pt.Distance(&pt1)

198 fmt.Println(pt, pt1)

改變函數調用方類型，試試結果的不同

go會根據調用方類型隱式轉換，所以197行可以正確運行

總結

以上是生活随笔為你收集整理的go数据结构整理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。