golang基础学习01切片数组

package main

import "fmt"

func main() {
	//testalice()
	//testAlicePrint()
	//modify()
	// modify2()
	//printlnSlice()
	//testAppend()
	//testCopy()
	kuoRong()

}

//声明切片数组
func testalice() {
	var slice1 []int //这个时候是nil
	slice1 = make([]int, 2)
	fmt.Println(slice1)
	slice2 := make([]int, 2)
	fmt.Println(slice2)
	//声明切片数组，下标从n开始到m-1结束个元素为切片的数组。（前闭后开）
	//缺省m则从n开始直到最后一个元素
	//缺省n时将表示从数组的第一个元素开始
	//[:]表示全部内容都是切片,[1:1]则没有任何值
	n := 1
	m := 2
	array := slice2[n:m]
	fmt.Println(array)
}

/**遍历切片数组**/
func testAlicePrint() {
	numbers := make([]int, 5)
	numbers[0] = 11
	numbers[1] = 12
	numbers[2] = 112
	numbers[3] = 15
	numbers[4] = 22
	//for e := range numbers {
	//	fmt.Println(numbers[e])
	//
	//}

	num := numbers[1:1]
	fmt.Println(num) //[11 12 112]
}

/**修改数组切片，直接修改原数组**/
func modify() {
	darr := [...]int{10, 2, 3, 5, 1}
	data := darr[2:5] //声明切片数组元素为：darr的下标3，4，5
	fmt.Println(darr)
	for e := range data {
		data[e]++
	}
	fmt.Println(darr)
	//[10 2 3 5 1]
	//[10 2 4 6 2]
}

/**修改数组切片，直接修改原数组**/
func modify2() {
	darr := [...]int{10, 2, 3, 5, 1}
	darr1 := darr[:]
	darr2 := darr[:]
	fmt.Println(darr)

	darr1[0] = 9
	fmt.Println(darr)
	darr2[0] = 12
	fmt.Println(darr)

}

/**
len()
cap()
**/
func printlnSlice() {

	var numbers []int
	printlnSlice2(numbers)
	numbers = append(numbers, 0)
	printlnSlice2(numbers)
	numbers = append(numbers, 1)
	printlnSlice2(numbers)

	numbers = append(numbers, 2, 3, 4)
	printlnSlice2(numbers)
	numbers1 := make([]int, len(numbers), (cap(numbers))*2)
	copy(numbers1, numbers)
	printlnSlice2(numbers1)
}
func printlnSlice2(x []int) {

	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

/**append()**/

func testAppend() {
	s1 := []int{3, 5, 22, 7}
	s2 := []int{1, 18, 43, 22}

	//将s2元素追加到s1
	//方法1
	//s1 = append(s1, s2...)
	//fmt.Printf("s1=%v", s1)
	//方法2
	for e := range s2 {
		s1 = append(s1, s2[e])
	}
	fmt.Printf("s1=%v", s1)
	//删除切片里的内容,思路：以被删除元素下标为切点数组分两段，后段为arr[:del]，前段为arr[del+1:]，然后将两个切片数组合并
	println("-------------------------")
	fmt.Println()
	s3 := s1
	del := 3

	fmt.Printf("s3=%v", s3[:del])
	fmt.Printf("s3=%v", s3[del+1:])

	s3 = append(s3[:del], s3[del+1:]...)
	fmt.Println(s3)
}

/*
  copy(),
	  切片是引用类型，传递的是地址

  深拷贝和浅拷贝
	  深拷贝：拷贝的是数据
		  值类型都是深拷贝，基本类型,数组
	  浅拷贝：拷贝的是地址
		  引用类型默认都是浅拷贝，切片，map
*/
func testCopy() {
	s1 := []int{5, 11, 66, 50}
	s2 := s1
	fmt.Println(s1, s2)
	s1[0] = 15
	fmt.Println(s1, s2)
	fmt.Println("----------------")
	a := 5
	b := a
	fmt.Println(a, b)
	b = 10
	fmt.Println(a, b)
	fmt.Println("----------------")

	n := []int{1, 11, 21, 5, 25}
	m := []int{4, 22, 14, 26, 65}
	fmt.Println(n)
	fmt.Println(m)
	fmt.Println("----------------")
	//copy(m, n) //将n中数据拷贝到m中
	//copy(n, m) //将m中的数据拷贝到n中
	//copy(n, m[1:4]) //将m中的2-4的数据拷贝到n中,两个数组下标2-4元素替换
	copy(n[1:], m[:3]) //将m中下标3到最后的元素，拷贝到n的下标1之后
	fmt.Println(n)
	fmt.Println(m)
	fmt.Println("-----------------")
	s3 := []int{1, 5, 11, 2}
	s4 := s3 //浅拷贝
	s5 := make([]int, 4, 4)
	copy(s5, s3) //深拷贝
	fmt.Println(s4)
	fmt.Println(s5)
	s3[0] = 22
	fmt.Println(s4)
	fmt.Println(s5)
}

/**切片的扩容**/
/*
   切片叫做变长数组，长度不固定
       len（），cap()

   当向切片中添加数据时，如果没有超过容量，直接添加，如果超过容量，自动扩容(成倍增长)
   3-->6-->12-->24-->48
   4-->8-->16-->32
*/
func kuoRong() {
	arr := []int{1, 2, 11, 22, 33, 2, 33, 6, 99, 88, 10}
	fmt.Println(arr)
	fmt.Printf("%p\n", arr)
	s1 := arr[:5]
	fmt.Println(s1)
	fmt.Printf("%p,长度：%d，容量：%d\n", s1, len(s1), cap(s1))
	s2 := arr[2:7]
	fmt.Println(s2)
	fmt.Printf("%p,长度：%d，容量：%d\n", s2, len(s2), cap(s2))
	fmt.Println("--------------------------")
	//修改切片数组，则是修改切片数组指向的底层数据。也就是说修改arr切片后的数组同时会修改arr
	s1[3] = 100
	fmt.Println(arr)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println("--------------------------")
	//追加切片数组的同时也会改变底层数组
	for i := 1; i < 10; i++ {
		s1 = append(s1, i+1)
	}

	fmt.Println(arr)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println("--------------------------")

}

//声明切片数组，下标从n开始到m-1结束个元素为切片的数组。（前闭后开）
//缺省m则从n开始直到最后一个元素
//缺省n时将表示从数组的第一个元素开始
//[:]表示全部内容都是切片,[1:1]则没有任何元素

修改切片数组，对切片数组进行添加，修改，修改操作时将会直接作用到底层数组。这里要说一个点，切片数组是引用类型传递。

而int，float，string等都是值类型传递，传递的是变量的副本。