4.Go语言-数组切片

1.数组

• 数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。 基本语法：

  // 数组长度必须是常量，且是类型的组成部分，一旦定义，长度不变。
  var a [3]int
  

• 数组可以通过下标进行访问，下标从0开始，最后一个元素下标是:len-1。

  // 遍历方式
  for i:=0;i<len(Arr);i++ {
  	
  }
  
  for index,v := range Arr {
      
  }
  

• 如果下标在数组的合法范围之外，则触发访问越界，会panic

var arr = [4]string{"1","2","3","4"}
fmt.Println(arr[5])
// 错误信息： invalid array index 5 (out of bounds for 4-element array)

• 数组的初始化：

  package main
  
  import "fmt"
  
  //数组相关内容
  func main() {
  	var a [3]int
  	var b [4]int
  	//注意a与b不能互相赋值，长度不同
  	fmt.Println(a, b)
  	//数组的初始化
  	//1定义时使用初始值列表的方式初始化
  	var cityArray = [4]string{"北京", "上海", "广州", "深圳"}
  	fmt.Println(cityArray)
  	fmt.Println(cityArray[3])
  	//2.编译器推导数组的长度
  	var boolArray = [...]bool{true, false, true, false, false}
  	fmt.Println(boolArray)
  	//3.使用索引值方式初始化
  	var langeArray = [...]string{1: "Golang", 3: "Python", 7: "Java"}
  	fmt.Println(langeArray)
  	fmt.Printf("%T
  ", langeArray)
  
  }
  

• 数组内定义结构体

  d := [...]struct {
      name string
      age uint16
  }{
      // 注意最后一行要加逗号，否则报错：syntax error: unexpected newline, expecting comma or {
      {"u1",123},
      {"u2",456},
      {"u3",789},
  }
  // [{u1 123} {u2 456} {u3 789}]
  fmt.Println(d)
  

• 数组的遍历：

  • for 循环遍历

  var cityArray = [4]string{"北京", "上海", "广州", "深圳"}
  	//1.for 循环遍历
  	 for i := 0; i < len(cityArray); i++ {
  	 	fmt.Println(cityArray[i])
  	}
  
  

  • for range循环遍历

  var cityArray = [4]string{"北京", "上海", "广州", "深圳"}
  	for index, value := range cityArray {
  		fmt.Println(index, value)
  	}
  

• 二维数组：

  • 注意：多维数组，只有最外层可以用[...]让编译器自己识别编译，内层不能使用。

  //定义一个多维数组
  cityArray := [...][2]string{
  		{"北京", "西安"},
  		{"上海", "重庆"},
  		{"杭州", "成都"},
  		{"广州", "深圳"},
  	}
  	//打印杭州
  	fmt.Println(cityArray[2][0])
  	//遍历循环二维数组，
  	for _, value1 := range cityArray {
  		for _, value2 := range value1 {
  			fmt.Println(value2)
  		}
  	}
  // demo2
  package main
  import "fmt"
  
  func main() {
      // 这里需要注意，第二个维度的不能使用"..."
  	var arr1 [2][3]int = [...][3]int{{1,2,3},{4,5,6}}
  	// [[1 2 3] [4 5 6]]
  	fmt.Println(arr1)
  }
  

• 数组类型

  • 数组是值类型，赋值和传参会赋值整个数组，而不是指针。所以改变副本的值，不会改变本身的值。

  var arr = [4]string{"1","2","3","4"}
  arr2 := arr
  arr2[3] = "10"
  fmt.Println(arr,arr2)
  // [1 2 3 4] [1 2 3 10]
  

  • demo

  package main
  
  import "fmt"
  
  //数组相关内容
  func main() {
  	//数组 是 值类型
  	x := [3]int{1, 2, 3}
  	fmt.Println(x)//[1 2 3]
  	f1(x)
      
      y:= x
      y[0] = 1000
      
  	fmt.Println(x)//[1 2 3]
  }
  
  func f1(a [3]int) {
  	a[0] = 100
  }
  //前后打印结果一样，数组是值类型，无论是把它当参数传到函数里，还是做一个变量赋值，它都是把数组的值完整拷贝一份再复制给变量
  //无论是一维数组，还是二维数组，还是给数组里的值赋值。它都不会改变
  

• 因数组是值拷贝，会造成性能问题，通常会建议使用slice,或数组指针

  package main
  import "fmt"
  
  func test(x [2]int) {
      // &x 
  	fmt.Printf("x: %p
  ",&x)
  	x[1] = 1000
  }
  
  
  func main() {
  	a := [2]int{}
  	fmt.Printf("a:%p
  ",&a)
  	test(a)
  	// a:0x1104a058
  	// x: 0x1104a078
  	// [0 0]
  }
  

  func printArr(arr *[5]int) {
  	arr[0] = 10
  }
  func main() {
  	var arr1 [5]int
  	printArr(&arr1)
  	// [10 0 0 0 0]
  	fmt.Println(arr1)
  }
  

• 通过len和cap返回数组长度

  a := [2]int{}
  println(len(a),cap(a))
  // 2 2
  

  • 练习题1：求数组和

  求数组[1,3,5,7,8]的所有元素和
  package main
  
  import "fmt"
  
  func main() {
  	// 练习题：
  	var result int
  	var sumList = [5]int{1, 3, 5, 7, 8}
  	for i := 0; i < len(sumList); i++ {
  		result += sumList[i]
  	}
  	fmt.Println(result)
  
  }
  找出数组中和为指定两个元素的下标，比如[1,3,5,7,8]和为8的两个元素下标分别为(0,3)和(1,2)
  package main
  
  import "fmt"
  
  func main() {
  	var sumList = [5]int{1, 3, 5, 7, 8}
  	for index, v1 := range sumList {
  		for temp, v2 := range sumList {
  			if index < temp && v1+v2 == 8 {
  				fmt.Println(index, temp)
  			}
  		}
  	}
  
  }
  

  • 求数组内随机数的和

  package main
  import (
  	"fmt"
  	"math/rand"
  	"time"
  )
  
  
  
  func sumArr(a [10]int) int {
  	var sum int = 0
  	for _,value := range a {
  		sum += value
  	}
  	return sum
  }
  
  
  func main() {
  	// 设置随机数种子， 可以保证每次随机都是随机的
  	rand.Seed(time.Now().Unix())
  	var b [10]int
  	for i:=0;i<len(b);i++ {
  		// 生成一个0-1000随机数
  		b[i] = rand.Intn(1000)
  	}
  	sum := sumArr(b)
  	fmt.Printf("sum=%d
  ",sum)
  }
  

• 找出数组中和为给定值的两个元素的下标，例如数组[1,3,5,8,7]，找出两个元素之和等于8的下标分别是（0，4）和（1，2）

  func testArr(arr [5]int, num int) {
  	for i:=0;i<len(arr);i++ {
  		for j:=i+1;j<len(arr);j++ {
  			if arr[i]+arr[j] == num {
  				fmt.Printf("(%d,%d)
  ",i,j)
  			}
  		}
  	}
  }
  
  func main() {
  	b := [5]int{1,3,5,8,7}
  	testArr(b,8)
  }
  

2.切片

• 首先slice切片并不是数组或数组指针，它用过内部指针和相关属性引用数组片段，从而实现变长方案。

  1.切片：切片是数组的一个引用，所以切片是引用类型，但自身是结构体，值拷贝传递
  2.切片的长度可以改变，因此切片是一个可变数组
  3.切片遍历方式和数组一样，可以用len求长度，表示可用元素数量，读写操作不能超过该限制。
  4.cap可以求出slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组。。
  5.切片的定义：var 变量名 []类型，比如 var str []string  var arr []int。
  6.如果 slice == nil，那么 len、cap 结果都等于 0。
  
  最终：
  切片是一个拥有相同类型元素的可变长度的序列，它基于数组类型做的一层封装，灵活度高，支持自动扩容，切片是一个引用类型，它的内部结构包含地址，长度和容量。切片一般用于快速地操作一块数据集合。
  

• 定义一个切片

  package main
  
  import "fmt"
  
  //生成切片(slice)
  func main() {
  	var a []string
  	var b []int
  	var c = []bool{false, true}
  	fmt.Println(a)
  	fmt.Println(b)
  	fmt.Println(c)
  }
  

• 切片的长度和容量

  • 切片拥有自己长度和容量，我们可以通过使用内置len函数求长度，使用内置cap()函数求切片容量。

• 基于数组切片

  package main
  
  import "fmt"
  
  //生成切片(slice)
  func main() {
  	//基于数组得到切片
  	a := [5]int{22, 23, 24, 25, 26}
  	b := a[1:4]
  	fmt.Println(b)
  	//打印类型
  	fmt.Printf("%T
  ", b)
  }
  

• make函数构造切片

  • len长度，cap计算切片容量

  package main
  
  import "fmt"
  
  //生成切片(slice)
  func main() {
  	//make函数构造函数
  	//d为一个元素个数为5，容量为10的切片
  	d := make([]int, 5, 10)
  	fmt.Println(d)
  	fmt.Printf("%T
  ", d)
      //通过len()函数获取切片的长度
  	fmt.Println(len(d))
  	//通过cap()函数获取切片的容量
  	fmt.Println(cap(d))
  //[0 0 0 0 0]
  //[]int
  //5
  //10
  

• 面试题：

  func main() {
  	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
  	s1 := arr[2:]
  	fmt.Println(s1)//[2 3 4 5 6 7]
  	//修改
  	s1[0] = 100
  	//是view的操作（切片映射数组），不同于python，python切片相当于单复制一份表
  	fmt.Println(s1)//[100 3 4 5 6 7] 
  	fmt.Println(arr)//[0 1 100 3 4 5 6 7]
  
  	s2 := arr[2:6]
  	fmt.Println(s2) //[100 3 4 5]
  	//前面不能取定死，可以从原数组往后面取（通过映射），超过了原数组长度会报错。但append不会报错
      // 错误信息：invalid slice index 10 (out of bounds for 5-element array)
  	s3 := s2[3:5]
  	fmt.Println(s3) //[5 6]
  	}
  

• 切片初始化

  全局：
  var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  var slice0 []int = arr[start:end] 
  var slice1 []int = arr[:end]        
  var slice2 []int = arr[start:]        
  var slice3 []int = arr[:] 
  var slice4 = arr[:len(arr)-1]      //去掉切片的最后一个元素
  局部：
  arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
  slice5 := arr[start:end]
  slice6 := arr[:end]        
  slice7 := arr[start:]     
  slice8 := arr[:]  
  slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素
  

• 切片原理：

  • 切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）

  • 举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。

  • 切片s2 := a[3:6]，相应示意图如下：

• nil

  • 切片之间不能直接比较，我们不能使用 == 操作符来判断两个切片是否含有全部相等元素，切片唯一合法的比较操作是和nil比较，一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0，但是我们不能说一个长度和容量为都是0的切片一定是nil.

  package main
  
  import "fmt"
  
  //生成切片(slice)
  func main() {
  	var a []int     //声明int类型切片
  	var b = []int{} //声明并且初始化，会再底层创建数组与其对应
  	c := make([]int, 0)
  	if a == nil {
  		fmt.Println("a是一个nil")
  	}
  	fmt.Println(a, len(a), cap(a))
  	if b == nil {
  		fmt.Println("b是一个nil")
  	}
  	fmt.Println(b, len(b), cap(b))
  	if c == nil {
  		fmt.Println("c是一个nil")
  	}
  	fmt.Println(c, len(c), cap(c))
  
  }
  
  

  • 切片的赋值拷贝

    • 下面的代码中演示了拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容，这点需要特别

    	s1 := make([]int, 3)
    	s2 := s1
    	s2[0] = 100
    	fmt.Println(s1)//[100 0 0]
    	fmt.Println(s2)//[100 0 0]
    

    • a赋值给了b，a和b共用一个底层数组，当我们把b[0]设置为100，打印出来a,b都更改

package main

import "fmt"

//生成切片(slice)
func main() {
	//切片的赋值拷贝
	a := make([]int, 3)
	b := a
	b[0] = 100
	fmt.Println(a)
	fmt.Println(b)

}
//[100,0,0]
//[100,0,0]


// 访问底层数组元素指针
s:= []int{0,1,2,3}
p := &[2]
*p += 100
fmt.Println(s)	// 102

• [][]T,元素类型为[]T

func main() {
	data := [][]int {
		[]int{1,2,3},
		[]int{100,200},
		[]int{11,22,33,44},
	}
	// [[1 2 3] [100 200] [11 22 33 44]]
	fmt.Println(data)
}

• 可直接修改struct array /slice 成员

package main

import "fmt"
func main() {
	d := [5]struct{
		x int
	}{}
	d[1].x = 10
	d[2].x = 20
	// [{0} {10} {20} {0} {0}]
    // 
	// 0x11010320,0x11010320
	fmt.Println(d)
	fmt.Printf("%p,%p
",&d,&d[0])
}

• 切片的遍历

package main

import "fmt"

func main() {
	//切片的遍历
	//索引遍历
	a := []int{1, 2, 3, 4, 5}
	for i := 0; i < len(a); i++ {
		fmt.Println(i, a[i])
	}
	//for...range遍历
	for index, value := range a {
		fmt.Println(index, value)
	}

}

• 切片的扩容
  • append 函数将元素值追加到数组的最后并返回数组
  • 当数组容量不满足继续放入元素，会发生扩容现象。切片numSlice的容量按照1，2，4，8，16这样规则自动进行扩容，每次扩容都是扩容前2倍

package main

import "fmt"

//生成切片(slice)
func main() {
	
	//切片要初始化后才能使用
	var a []int //此时并没有申请内存

	for i := 0; i < 10; i++ {
		a = append(a, i) //需要变量来接收，因为你不知道原来数组是否会扩容
		fmt.Printf("%v len:%d cap:%d ptr:%p
", a, len(a), cap(a), a)
	}

}
// [0] len:1 cap:2 ptr:0x11010080
// [0 1] len:2 cap:2 ptr:0x11010080
// [0 1 2] len:3 cap:4 ptr:0x110100d0
// [0 1 2 3] len:4 cap:4 ptr:0x110100d0
// [0 1 2 3 4] len:5 cap:8 ptr:0x1100e3a0
// [0 1 2 3 4 5] len:6 cap:8 ptr:0x1100e3a0
// [0 1 2 3 4 5 6] len:7 cap:8 ptr:0x1100e3a0
// [0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0x1100e3a0
// [0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0x1100c280
// [0 1 2 3 4 5 6 7 8 9] len:10 cap:16 ptr:0x1100c280

• append支持一次性添加多个元素

package main

import "fmt"

//生成切片(slice)
func main() {
	
	//切片要初始化后才能使用
	var a []int //此时并没有申请内存
	a = append(a,1,2,3,4,5)
    b:=[]int{11,12,13}
    a = append(a,b...)//将切片b加入到里面必须使用...
	fmt.Println(a)
	}
[1 2 3 4 5 11 12 13 14]

• 切片区别python对比go

  #python
  a = [1,2,3,4,5,6]
  t = a[0:4]
  t[0] = 100
  print(t)#[100, 2, 3, 4]
  print(a)#[1, 2, 3, 4, 5, 6]
  
  p = a[0:5]
  print(p)#[1, 2, 3, 4, 5]
  p.append(1000)
  print(p)#[1, 2, 3, 4, 5, 1000]
  print(a)#[1, 2, 3, 4, 5, 6]
  #python切片后赋值数据，做更改，增添，都不会影响源数据以及以后切片数据，像深拷贝
  
  #go
  func main() {
  	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
  	s1 := arr[2:]
  	fmt.Println(s1)//[2 3 4 5 6 7]
  	//修改
  	s1[0] = 100
  	//是view的操作（切片映射数组），不同于python，python切片相当于单复制一份表
  	fmt.Println(s1)//[100 3 4 5 6 7] 
  	fmt.Println(arr)//[0 1 100 3 4 5 6 7]
  
  	s2 := arr[2:6]
  	fmt.Println(s2) //[100 3 4 5]
  	//前面不能不取定死，可以从原数组往后面取（通过映射），超过了原数组长度会报错。
  	s3 := s2[3:5]
  	fmt.Println(s3) //[5 6]
  }
  #go语言，切片相当于映射数组，当切片更改数据，源数组也会更改，后续切片数据也会更改。
  

• 总结：

  - 首先，如果新申请容量（cap) 大于2倍的旧容量（old.cap),最终容量(newcap)就是新申请的容量（cap）
  - 否则判断，如果旧切片长度小于1024，则最终容量（newcap）就是旧容量的两倍，即（newcap= doublecap）
  - 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap.for{newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量（cap），即（newcap >= cap）
  - 如果最终容量（cap）计算值溢出，则最终容量（cap） 就是新申请容量（cap）
  
  ！需要注意的是:切片扩容还会根据切片中元素的类型不同而做不同的处理，比如int和string类型的处理方式就不一样。
  

• copy函数应用

  package main
  
  import "fmt"
  
  func main() {
  	//切片的copy
  	a := []int{1, 2, 3, 4, 5}
  	b := make([]int, 5, 5)
  	c := b//c为b的赋值，c指向的地址与b一样
  	copy(b, a)//b切片为从a拷贝过来的，指向新的地址
  	b[0] = 100
  	fmt.Println(a)
  	fmt.Println(b)
  	fmt.Println(c)
  }
  //所以当b第0个元素发生变化，c也跟着变化，而a不发生变化
  //[1 2 3 4 5]
  //[100 2 3 4 5]
  //[100 2 3 4 5]
  

• copy 函数在两个slice间复制数据，复制长度以len小的为准，两个slice可指向同一底层数组，允许元素区间重叠

  func main() {
  
      data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
      fmt.Println("array data : ", data)
      s1 := data[8:]
      s2 := data[:5]
      fmt.Printf("slice s1 : %v
  ", s1)
      fmt.Printf("slice s2 : %v
  ", s2)
      // 将s1元素拷贝到s2上，并覆盖
      copy(s2, s1)
      fmt.Printf("copied slice s1 : %v
  ", s1)
      fmt.Printf("copied slice s2 : %v
  ", s2)
      fmt.Println("last array data : ", data)
  
  }
  // array data :  [0 1 2 3 4 5 6 7 8 9]
  // slice s1 : [8 9]
  // slice s2 : [0 1 2 3 4]
  // copied slice s1 : [8 9]
  // copied slice s2 : [8 9 2 3 4]
  // last array data :  [8 9 2 3 4 5 6 7 8 9]
  

• 切片resize,调整大小

  var a = []int{1,3,4,5}
  fmt.Printf("%v,%v
  ",a,len(a))
  b := a[1:2]
  fmt.Printf("%v,%v
  ",b,len(b))
  c := b[0:3]
  fmt.Printf("%v,%v
  ",c,len(c))
  
  // [1 3 4 5],4
  // [3],1
  // [3 4 5],3
  

• 切片元素的删除

  //从切片a中删除"青岛"
  package main
  
  import "fmt"
  
  func main() {
  	//切片删除元素
  	a := []string{"北京", "上海", "青岛", "深圳"}
  	a = append(a[0:2], a[3:]...)
  	fmt.Println(a)
  }
  //[北京 上海 深圳]
  

练习题

//1.请写出下面代码的输出结果
func main() {
	var a = make([]string,5,10)//此时切片容量10，里面已经有5个空格
	for i:=0;i<10;i++{
		a.append(a,fmt.Sprintf("%v",i))//当添加元素0，1，2，3，4此时a容量已经满了，而append恰好能对其进行扩容
	}
	fmt.Println(a)
}
//最后输出结果：
//[     0 1 2 3 4 5 6 7 8 9]

//2.排序题
package main

import (
	"fmt"
	"sort"
)

func main() {
	//切片删除元素
	// a := []string{"北京", "上海", "青岛", "深圳"}
	// a = append(a[0:2], a[3:]...)
	// fmt.Println(a)
	var a = [...]int{3, 7, 8, 1, 9}//a为int类型数组
	sort.Ints(a[:])//接收参数为int类型切片。其实a[:]得到的切片，指向底层数组a,对切片排序，相当于对数组a排序
	fmt.Println(a)
}