Golang基礎之陣列
文章轉載請註明出處www.leexide.com
希望每一位尋求轉載的朋友都能夠按照要求進行,鼓勵原創,尊重原創。
微信公眾號:DevOps運維運營之家
QQ號碼:1045884038
E-mail:[email protected]
如有問題或建議,請關注微信公眾號
1 陣列介紹
陣列是同一型別元素的集合。例如,整數集合 5,8,9,79,76 形成一個數組。Go 語言中不允許混合不同型別的元素,例如包含字串和整數的陣列。(注:當然,如果是 interface{} 型別陣列,可以包含任意型別) 。
2 陣列常見操作
一個數組的表示形式為 [n]T
。n
T
代表每個元素的型別。元素的數量 n
也是該型別的一部分 。
2.1 陣列初始化
一維陣列初始化如下
func main() {
var a [4]int //元素自動初始化為零[0 0 0 0]
b := [4]int{2, 5} //未提供初始化值得元素自動初始化為0 [2 5 0 0]
c := [4]int{5, 3: 10} //可指定索引位置初始化 [5 0 0 10]
d := [...]int{1, 2, 3} //編譯器按初始化值數量確定陣列長度 [1 2 3]
e := [...]int{10, 3: 100} //支援索引初始化,但注意陣列長度與此有關 [10 0 0 100]
fmt.Println(a, b, c, d, e)
}
對於結構等複合型別,可省略元素初始化型別標籤
package main
import "fmt"
func main() {
type user struct {
name string
age byte
}
d := [...]user{
{"tom", 20},// 可省略元素型別。
{"lee", 18},// 別忘了最後一行的逗號。
}
fmt.Printf("%#v\n", d)
}
/*output
[2]main.user{main.user{name:"tom", age:0x14}, main.user{name:"lee", age:0x12}}
*/
在定義多維陣列時,僅第一維度允許使用“…”
package main
import "fmt"
func main() {
a := [2][2]int{
{1, 2},
{3, 4},
}
b := [...][2]int{
{10, 20},
{30, 40},
}
c := [...][2][2]int{ //三維陣列
{
{1, 2},
{3, 4},
},
{
{10, 20},
{30, 40},
},
}
fmt.Println(a) //[[1 2] [3 4]]
fmt.Println(b) //[[10 20] [30 40]]
fmt.Println(c) //[[[1 2] [3 4]] [[10 20] [30 40]]]
}
多維陣列定義
package main
import (
"fmt"
)
var arr0 [5][3]int
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
func main() {
a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 緯度不能用 "..."。
fmt.Println(arr0, arr1)
fmt.Println(a, b)
}
/*
output
[[0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]] [[1 2 3] [7 8 9]]
[[1 2 3] [4 5 6]] [[1 1] [2 2] [3 3]]
*/
2.2 陣列索引
陣列的索引從 0
開始到 length - 1
結束
func main() {
var a [3]int //int array with length 3
a[0] = 12 // array index starts at 0
a[1] = 78
a[2] = 50
fmt.Println(a)
}
2.3 陣列是值型別
Go 中的陣列是值型別而不是引用型別。這意味著當陣列賦值給一個新的變數時,該變數會得到一個原始陣列的一個副本。如果對新變數進行更改,則不會影響原始陣列。
func main() {
a := [...]string{"USA", "China", "India", "Germany", "France"}
b := a // a copy of a is assigned to b
b[0] = "Singapore"
fmt.Println("a is ", a) //a is [USA China India Germany France]
fmt.Println("b is ", b) //b is [Singapore China India Germany France]
}
上述程式中,a
的副本被賦給 b
。在第 4 行中,b
的第一個元素改為 Singapore
。這不會在原始陣列 a
中反映出來。
同樣,當陣列作為引數傳遞給函式時,它們是按值傳遞,而原始陣列保持不變。
package main
import "fmt"
func changeLocal(num [5]int) {
num[0] = 55
fmt.Println("inside function ", num)
}
func main() {
num := [...]int{5, 6, 7, 8, 8}
fmt.Println("before passing to function ", num)
changeLocal(num) //num is passed by value
fmt.Println("after passing to function ", num)
}
/*output
before passing to function [5 6 7 8 8]
inside function [55 6 7 8 8]
after passing to function [5 6 7 8 8]
*/
在上述程式的 13 行中, 陣列 num
實際上是通過值傳遞給函式 changeLocal
,陣列不會因為函式呼叫而改變。
值拷貝行為會造成效能問題,通常會建議使用 slice,或陣列指標。
package main
import (
"fmt"
)
func test(x [2]int) {
fmt.Printf("x: %p\n", &x)
x[1] = 1000
}
func main() {
a := [2]int{}
fmt.Printf("a: %p\n", &a)
test(a)
fmt.Println(a)
}
/*
output:
a: 0xc042062080
x: 0xc0420620c0
[0 0]
*/
2.4 陣列長度和元素數量
通過將陣列作為引數傳遞給 len
函式,可以得到陣列的長度。 cap
可以得到元素數量
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
fmt.Println("length of a is", len(a)) //length of a is 4
fmt.Println("num of a is",cap(a)) //num of a is 4
}
注意:內建函式len和cap都返回第一維度長度
package main
func main() {
a := [2]int{}
b := [...][2]int{
{10, 20},
{30, 40},
{50, 60},
}
println(len(a), cap(a)) // 2 2
println(len(b), cap(b)) // 3 3
println(len(b[1]), cap(b[1])) // 2 2
}
2.5 使用 range 迭代陣列
for
迴圈可用於遍歷陣列中的元素。
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
for i := 0; i < len(a); i++ { // looping from 0 to the length of the array
fmt.Printf("%d th element of a is %.2f\n", i, a[i])
}
}
上面的程式使用 for
迴圈遍歷陣列中的元素,從索引 0
到 length of the array - 1
Go 提供了一種更好、更簡潔的方法,通過使用 for
迴圈的 range 方法來遍歷陣列。range
返回索引和該索引處的值。讓我們使用 range 重寫上面的程式碼。我們還可以獲取陣列中所有元素的總和。
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
sum := float64(0)
for i, v := range a { //range returns both the index and value
fmt.Printf("%d the element of a is %.2f\n", i, v)
sum += v
}
fmt.Println("\nsum of all elements of a", sum)
}
上述程式的第 8 行 for i, v := range a
利用的是 for 迴圈 range 方式。 它將返回索引和該索引處的值。 我們列印這些值,並計算陣列 a
中所有元素的總和。
如果你只需要值並希望忽略索引,則可以通過用 _
空白識別符號替換索引來執行。
for _, v := range a { // ignores index }
上面的 for 迴圈忽略索引,同樣值也可以被忽略。
2.6 陣列操作符操作
如元素型別支援”==,!=”操作符,那麼陣列也支援此操作
package main
func main() {
var a, b [2]int
println(a == b) //true
c := [2]int{1, 2}
d := [2]int{0, 1}
println(c != d) //true
/*
var e, f [2]map[string]int
println(e == f) //invalid operation: e == f ([2]map[string]int cannot be compared)
*/
}
3 陣列高階用法
3.1 多維陣列
到目前為止我們建立的陣列都是一維的,Go 語言可以建立多維陣列。
package main
import (
"fmt"
)
func printArray(a [3][2]string) {
for _, v1 := range a {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
}
func main() {
a := [3][2]string{
{"lion", "tiger"},
{"cat", "dog"},
{"pigeon", "peacock"}, // this comma is necessary. The compiler will complain if you omit this comma
}
printArray(a)
var b [3][2]string
b[0][0] = "apple"
b[0][1] = "samsung"
b[1][0] = "microsoft"
b[1][1] = "google"
b[2][0] = "AT&T"
b[2][1] = "T-Mobile"
fmt.Printf("\n")
printArray(b)
}
/*output
lion tiger
cat dog
pigeon peacock
apple samsung
microsoft google
AT&T T-Mobile
*/
多維陣列遍歷
package main
import (
"fmt"
)
func main() {
var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
for k1, v1 := range f {
for k2, v2 := range v1 {
fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
}
fmt.Println()
}
}
/*
output:
(0,0)=1 (0,1)=2 (0,2)=3
(1,0)=7 (1,1)=8 (1,2)=9
*/
3.2 陣列指標和指標陣列
要分清指標陣列和陣列指標的區別。指標陣列是指元素為指標型別的陣列,陣列指標是獲取陣列變數的地址。
package main
import "fmt"
func main() {
x, y := 10, 20
a := [...]*int{&x, &y}
p := &a
fmt.Printf("%T,%v\n", a, a) //[2]*int,[0xc042062080 0xc042062088]
fmt.Printf("%T,%v\n", p, p) //*[2]*int,&[0xc042062080 0xc042062088]
}
可獲取任意元素地址
func main() {
a := [...]int{1, 2}
println(&a, &a[0], &a[1]) //0xc042049f68 0xc042049f68 0xc042049f70
}
陣列指標可以直接用來操作元素
func main() {
a := [...]int{1, 2}
p := &a
p[1] += 10
println(p[1]) //12
}
4 陣列使用常見坑
定義陣列型別時,陣列長度必須是非負整型常量表達式,長度是型別組成部分。也就是說,元素型別相同,但長度不同的陣列不屬於同一型別。
例子:
func main() {
var d1 [3]int
var d2 [2]int
d1 = d2 //cannot use d2 (type [2]int) as type [3]int in assignment
}
5 陣列總結
陣列:是同一種資料型別的固定長度的序列。
陣列定義:
var a [len]int
,比如:var a [5]int
,陣列長度必須是常量,且是型別的組成部分。一旦定義,長度不能變。長度是陣列型別的一部分,因此,
var a[5] int
和var a[10]int
是不同的型別。陣列可以通過下標進行訪問,下標是從
0
開始,最後一個元素下標是:len-1
。陣列索引常用操作如下:for i := 0; i < len(a); i++ { ... } for index, v := range a { ... }
訪問越界,如果下標在數組合法範圍之外,則觸發訪問越界,會
panic
陣列是值型別,賦值和傳參會複製整個陣列,而不是指標。因此改變副本的值,不會改變本身的值。
支援 “==”、”!=” 操作符,因為記憶體總是被初始化過的。
指標陣列
[n]*T
,陣列指標*[n]T
。
相關推薦
Golang基礎之陣列
文章轉載請註明出處www.leexide.com 希望每一位尋求轉載的朋友都能夠按照要求進行,鼓勵原創,尊重原創。 微信公眾號:DevOps運維運營之家 QQ號碼:1045884038 E-mail:[email protected]
golang基礎之數組
golang數組 go數組 golang基礎 文章轉載請註明出處www.leexide.com 希望每一位尋求轉載的朋友都能夠按照要求進行,鼓勵原創,尊重原創。 微信公眾號:DevOps運維運營之家 QQ號碼:1045884038 E-mail:[email protected] 如有問題或建議,請關
golang基礎之三-字串,時間,流程控制,函式
strings和strconv的使用 strings strings.HasPrefix(s string,preffix string) bool:判斷字串s是否以prefix開頭 stirngs.HasSuffix(s string,suffix string) bool:判斷字串s是否以suffi
golang基礎之三-字符串,時間,流程控制,函數
替換 單個 field Golan right mic 寫法 clas \n strings和strconv的使用 strings strings.HasPrefix(s string,preffix string) bool:判斷字符串s是否以prefix開頭 stirn
java基礎之陣列
public static void main(String[] args) { int[] arr = new int[]{34, 23, 56, 21, 19,68,10}; System.out.print("反轉前:"); for (
GOLANG 學習之陣列
陣列是值型別 [10]int和[20]int是不同型別 呼叫func f(arr [5]int)會拷貝陣列 在go語言中一般不直接使用陣列 申明一個數組 // variable_name-變數名稱
js基礎之陣列例項方法
toString() 方法 陣列的toString方法返回陣列的字串形式 let arr = ['it', 'he', 'she']; arr.toString(); // "it,he,she" let arr = ['it', 'he', 'she', ['1', '2',
Java基礎之 陣列詳解
前言:Java內功心法之陣列詳解,看完這篇你向Java大神的路上又邁出了一步(有什麼問題或者需要資料可以聯絡我的扣扣:734999078) 陣列概念 同一種類型資料的集合。其實陣列就是一個容器。 陣列的好處 可以自動給陣列中的元素從0開始編號,方便操作這些元素。 格式1:
go語音基礎之陣列比較和賦值
1、go語音基礎之陣列比較和賦值 示例: package main //必須有個main包 import "fmt" func main() { //支援比較,只支援 == 或 !=, 比較是不是每一個元素都一樣,2個數組比較,陣列型別要一樣 a := [5]int{1, 2,
黑馬程式設計師——Java語言基礎之陣列
八、陣列 1、定義:同一種資料型別的集合,其實質就是一個容器。 2、好處:自動給陣列的元素從0開始編號,方便操作。 3、格式1: 元素型別[ ] 陣列名= new 元素型別 [元素的個數或者陣列的長度] ;
golang基礎之初識
例如 速度 最大 轉發 其他 python 所有 delete cap golang 簡介 很久以前,有一個IT公司,這公司有個傳統,允許員工擁有20%自由時間來開發實驗性項目。在2007的某一天,公司的幾個大牛,正在用c++開發一些比較繁瑣但是核心的工作,主要包括龐大的分
Go語言基礎之陣列
Go語言基礎之陣列 本文主要介紹Go語言中陣列(array)及它的基本使用。 Array ( 陣列 ) 陣列是同一種資料型別元素的集合。 在Go語言中,陣列從宣告時就確定,使用時可以修改陣列成員,但是陣列大小不可變化。 基本語法: // 定義一個長度為3元素型別為int的陣列a var a [3]int 陣列
Java基礎之字串陣列Array進行去重
寫出一段演算法,用於對字串陣列進行去重,要求儘量簡潔 舉例: * 輸入: * {"cc","dd","aa","cc","gg","dd","ee"} * 輸出: * {"cc","dd","aa","gg","ee"} ArrayList去重 通過list.contains()
黑馬程式設計師——Java基礎之函式與陣列
------- <a href="http://www.itheima.com" target="blank">android培訓</a>、<a href="http://www.itheima.com" target="blank">java培訓</a&g
golang基礎學習----Go 語言陣列
陣列定義 陣列是具有相同唯一型別的一組已編號且長度固定的資料項序列(這是一種同構的資料結構);這種型別可以是任意的原始型別例如整形、字串或者自定義型別。陣列長度必須是一個常量表達式,並且必須是一個非負整數。需要強調:陣列長度也是陣列型別的一部分。 Go語言陣列 陣列是Go語言程式設
golang基礎學習01切片陣列
//宣告切片陣列,下標從n開始到m-1結束個元素為切片的陣列。(前閉後開) //預設m則從n開始直到最後一個元素 //預設n時將表示從陣列的第一個元素開始 //[:]表示全部內容都是切片,[1:1]則沒有任何值 package main import "fmt" func main
Java基礎及提高 之 陣列,List,Set,Map的幾種遍歷方式
一,陣列的遍歷方式 陣列有兩種遍歷方式: public class ArrayXunhuan { public static void main(String[] args) { int[
noi題庫1.8程式設計基礎之多維陣列:題解大禮包20180918
題目傳送門 以下是對noi題庫1.8的全部題解,有需要的同學請自行學習。 有任何錯漏或者疑問,請留言。謝謝~~~ 1、題目分析 2、程式碼截圖 1.8程式設計基礎之多為陣列 編號 題目 相對難度1-5 知識點 1 矩陣交換行 2
《C++語言程式設計基礎》學習之陣列指標與字串
陣列元素在記憶體中順次存放,它們的地址是連續的。元素間實體地址上的相鄰,對應著邏輯次序上的相鄰。 陣列名字是陣列首元素的記憶體地址,陣列名是常量,不能被賦值 陣列名是陣列的指標,指向首個元素的地址,多維陣列的n-1維是指標一維陣列初始化: 在定義陣列時給出陣列元素的初始值:列
22:神奇的幻方/NOI / 1.8程式設計基礎之多維陣列
總時間限制: 1000ms 記憶體限制: 65535kB 描述 幻方是一個很神奇的N*N矩陣,它的每行、每列與對角線,加起來的數字和都是相同的。 我們可以通過以下方法構建一個幻方。(