func main() {
var a [1]int
var b [2]int
//这里的a和b虽然都是数组,但是长度不一样,类型也不一样所以不能运算
b = a
fmt.Println(b)
}
# command-line-arguments
./basic_structure.go:32:4: cannot use a (type [1]int) as type [2]int in assignment
func main() {
var a [1]int
var b [1]int
//这里的a和b虽然都是数组,但是长度不一样,类型也不一样所以不能运算
b = a
fmt.Println(b)
}
[0]
因为是整型 又没有默认值
func main() {
a := [5]int{}
fmt.Println(a)
}
[0 0 0 0 0]
因为是字符串 又没有默认值
func main() {
a := [5]string{}
fmt.Println(a)
}
[ ]
前三个值是1,2,3 剩下的默认值
func main() {
a:=[5]int{1,2,3}
fmt.Println(a)
}
[1 2 3 0 0]
第1个key是1 第4个key是5 剩下的默认值
func main() {
a := [5]int{1: 1, 4: 5}
fmt.Println(a)
}
[0 1 0 0 5]
不指定数组长度 go自定计算
func main() {
a := [...]int{1, 2, 3, 4, 5}
fmt.Println(a)
}
[1 2 3 4 5]
不指定数组长度 go自定计算
func main() {
a := [...]int{4: 5}
fmt.Println(a)
}
[0 0 0 0 5]
分别取出x和y的指针,放到
func main() {
x, y := 1, 2
//取出值的指针放到数组
a := [...]*int{&x, &y}
fmt.Println(a)
}
[0xc420016090 0xc420016098]
func main() {
a := [...]int{4: 1}
var p *[5]int = &a
fmt.Println(p)
}
其实也是输出a的值,,但是前面有个 & 符号.表示取
[0 0 0 0 1]
数组的地址
&[0 0 0 0 1]
func main() {
p := new([10]int)
fmt.Println(p)
}
&[0 0 0 0 0 0 0 0 0 0]
func main() {
a := [10]int{}
p := new([10]int)
a[1] = 1
p[1] = 1
fmt.Println(a)
fmt.Println(p)
}
不管你是用什么方式创建的数组,都是可以通过a[n]=y 的方式来修改数组中的值
[0 1 0 0 0 0 0 0 0 0]
&[0 1 0 0 0 0 0 0 0 0]
func main() {
a := [2][3]int{
{1, 1, 1},
{2, 2, 2},
}
fmt.Println(a)
}
[[1 1 1] [2 2 2]]
只有最顶级的元素才可以使用...自动计算
func main() {
a := [...][3]int{
{},
{2, 2, 2},
{1: 1, 2: 3},
}
fmt.Println(a)
}
[[0 0 0] [2 2 2] [0 1 3]]
func main() {
a := [...]int{1, 4, 5, 6, 0, 9}
fmt.Println(a)
len := len(a)
for i := 0; i < len; i++ {
for j := i + 1; j < len; j++ {
if a[i] < a[j] {
temp := a[i]
a[i] = a[j]
a[j] = temp
}
}
}
fmt.Println(a)
}
[1 4 5 6 0 9]
[9 6 5 4 1 0]
func main() {
s1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Println(s1)
s2 := s1[5:10] //左开右闭 [6 7 8 9 0]
s3 := s1[5:] //从第6个取到结尾
s4 := s1[5:len(s1)] //从第6个取到结尾
s5 := s1[:5] //取前五个
fmt.Println(s2)
fmt.Println(s3)
fmt.Println(s4)
fmt.Println(s5)
}
[1 2 3 4 5 6 7 8 9 0]
[6 7 8 9 0]
[6 7 8 9 0]
[6 7 8 9 0]
[1 2 3 4 5]
func main() {
s1 := make([]int, 3, 10)
fmt.Println(s1)
fmt.Printf("s1的内存地址 : %p , %v\n", &s1)
}
[0 0 0]
s1的内存地址 : 0xc4200aa020 , %!v(MISSING)
如果不给数据容量,将会是你当前数据的长度
func main() {
a:=[]byte{'a','b','c','d','e','f','g','h','i','j','k'}
//此时 sa 已经是 defghi
sa := a[3:9]
//如果我们想要从sa中取出de索引值就就是0:2了..而不是在a中取出的3:5
sb := sa[0:2]
fmt.Println(string(sa),len(sa),cap(sa))
fmt.Println(string(sb),len(sb),cap(sb))
}
func main() {
s1 := make([]int, 3, 6)
fmt.Printf("%v %p\n", s1, s1)
s1 = append(s1, 1, 2, 3)
//追加3个元素,刚刚达到最大容量,所以内存地址是不变的
fmt.Printf("%v %p\n", s1, s1)
fmt.Println(cap(s1))
s1 = append(s1, 1, 2, 3)
//这里很明显再追加3个元素已经超过最开始定的6个容量,所以内存地址已经变了
fmt.Printf("%v %p\n", s1, s1)
//容量也 X2 了
fmt.Println(cap(s1))
}
[0 0 0] 0xc42001e0f0
[0 0 0 1 2 3] 0xc42001e0f0
6
[0 0 0 1 2 3 1 2 3] 0xc4200180c0
12
func main() {
a := []int{1, 2, 3, 4, 5}
s1 := a[2:5]
s2 := a[1:3]
fmt.Println(s1, s2)
//这时候我们改变a中s1和s2共同的一个值3 改为 9
a[2] = 9
//也能看到他们都变成了9 这说明.. 他们都是指向a这个数组的
fmt.Println(s1, s2)
}
[3 4 5] [2 3]
[9 4 5] [2 9]
func main() {
a := []int{1, 2, 3, 4, 5}
s1 := a[2:5]
s2 := a[1:3]
fmt.Println(s1, s2)
//我正在这里append了3个元素到s2中,这时候已经超过最大容量了,所以就重新分配了内存快
s2 = append(s2,1,2,4)
fmt.Println(cap(s2))
//因为s2重新分配了内存块,所以这里只会影响到s1,并不会影响到s2
//如果你的append元素个数没有超过容量的话,还是会影响s2的
a[2] = 9
fmt.Println(s1, s2)
}
[3 4 5] [2 3]
8
[9 4 5] [2 3 1 2 4]
copy(A,B) 将B拷贝到A中
这时候就按照数组下标以此替换就好
func main() {
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{6, 7, 8, 9, 10, 11, 12, 13, 14}
copy(s2, s1)
fmt.Print(s2)
}
[1 2 3 4 5 11 12 13 14]
这时候就按照数组下标以此替换就好,同时只替换A个元素
func main() {
s3 := []int{1, 2, 3, 4, 5}
s4 := []int{6, 7}
copy(s4, s3)
fmt.Print(s4)
}
[1 2]
这个就直接用A替换B
当然不一定都要同时指定
func main() {
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{6, 7, 8, 9, 10, 11, 12, 13}
//这里也可以指定A/B的下标指定拷贝
copy(s2[0:2], s1[3:5])
fmt.Print(s2)
}
[4 5 8 9 10 11 12 13]
func main() {
//i就是slice的索引 是int 型, 也算一个计数器
//v就是slice中的值.. v只是slice中的值的一个拷贝,你修改v是不会影响到slice中的值的
//如果要修改slice中的值你需要用: slice[i] 来改变值
slice := [...]int{1,2,3,4,5}
for i, v := range slice {
fmt.Println(i,v)
}
}
0 1
1 2
2 3
3 4
4 5