package main
import (
	"fmt"
)
func main() {
	numa := [3]int{78, 79, 80}
	nums1 := numa[:]
	nums2 := numa[:]
	fmt.Println("array before change 1", numa)
	nums1[0] = 100
	fmt.Println("array after modification to slice nums1", numa)
	nums2[1] = 101
	fmt.Println("array after modification to slice nums2", numa)
}

// output
array before change 1 [78 79 80]
array after modification to slice nums1 [100 79 80]
array after modification to slice nums2 [100 101 80]

// 通過數(shù)組定義切片
var array1 = [3]int{1, 1, 3}
fmt.Println("數(shù)組的元素分別是:", array1)
slice1 := array1[0:2]
slice1[1] = 11111
fmt.Println("數(shù)組的元素分別是:", array1)

// 通過數(shù)組定義切片
array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
slice := array(0:5)
// 打印結(jié)果為
[A B C D E]

// 使用make方式創(chuàng)建切片
slice1 := make([]string, 2, 3)
slice1[0] = "1"
fmt.Println(slice1)

slice2 := make([]string, 2, 3)
fmt.Println(slice2)

fmt.Println("切片的長度為", len(slice1))
fmt.Println("切片的容量為", cap(slice1))
// output
[1 ]
[ ]
切片的長度為 2
切片的容量為 3

// 切片定義省略開始和結(jié)束位置
array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
fmt.Println("開始位置和結(jié)束位置都缺省",array[:])
// output
開始位置和結(jié)束位置都缺省 [A B C D E F G H I G K L]

// 起始位置和結(jié)束位置都不省略
array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
slice := array(0:5)
// output
[A B C D E]

// 起始位置省略，結(jié)束位置都不省略
array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
slice := array(:5)
// output
[A B C D E]

// 起始位置不省略，結(jié)束位置省略
array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
fmt.Println("缺省結(jié)束位置:",array[2:])
// 打印結(jié)果為
缺省結(jié)束位置: [C D E F G H I G K L]

array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
fmt.Println("切片",array[-1:100])
// 打印結(jié)果為
invalid slice index -1 (index must be non-negative)

// 起始位置和結(jié)束位置都為0
array := []string{"A","B","C","D","E","F","G","H","I","G","K","L"}
fmt.Println("切片",array[0:0])
// 打印結(jié)果為
切片: []

// 也可以通過一個空的數(shù)組形式
var slice []type

// 聲明一個整型切片
var slice1 []int
// 初始化一個切片
var slice2 []int = []int{}

// 定義切片
slice1 := make([]string, 2, 3)
slice1[0] = "1"
fmt.Println(slice1)
// 打印如下結(jié)果
[1 ]

// 計(jì)算切片長度
slice1 := make([]string, 2, 3)
fmt.Println("切片的長度為", len(slice1))
// 打印結(jié)果為
切片的長度為 2

// 計(jì)算切片長度
slice1 := make([]string, 2, 3)
fmt.Println("切片的長度為", cap(slice1))
// 打印結(jié)果為
切片的容量為 3

// 判斷空切片
slice3 := make([]string, 2, 3)
if slice3 == nil {
	fmt.Println("slice3是空切片")
} else {
	fmt.Println("slice3不是空切片")
}

var slice4 []string
if slice4 == nil {
	fmt.Println("slice4是空切片")
} else {
	fmt.Println("slice4不是空切片")
}

// output
slice3不是空切片
slice4是空切片

// 錯誤演示
slice1 := make([]int, 2, 5)
slice2 := make([]int, 2, 5)
if slice1 == slice2 {
	fmt.Println("相等")
} else {
	fmt.Println("不想等")
}

// output
slice1 == slice2 (slice can only be compared to nil)

append(slice, element)

// 切片的開始位置追加元素
var slice []int = []int {1,2,3}

// 打印原始切片的長度和容量
fmt.Println("原始切片長度和容量分別是", len(slice), cap(slice))

// 向切片后面追加一個元素
slice = append(slice, 1)
fmt.Println(slice)

// 向切片后面追加多個元素
slice = append(slice, 6,7,8,9)
fmt.Println(slice)

// 打印新的切片的長度和容量
fmt.Println("新切片長度和容量分別是", len(slice), cap(slice))

// 打印的內(nèi)容分別如下
原始切片長度和容量分別是 3 3
[1 2 3 1]
[1 2 3 1 6 7 8 9]
新切片長度和容量分別是 8 12

// 驗(yàn)證切片追加元素自動擴(kuò)容
var numbers []int
for i := 0; i < 10; i++ {
    numbers = append(numbers, i)
    fmt.Printf("len: %d  cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers)
}

// 向切片的開始位置追加元素
var slice = []int {1,2,3}
slice = append([]int {0}, slice...) // 在開頭添加只有1個元素的切片
slice = append([]int {-3,-2,-1}, slice...) // 在開頭添加擁有多個元素的切片
fmt.Println(slice)

// 向切片的中間追加元素
var slice2 = []int {1,2,3,7,8,9}
slice2 = append(slice2[0:3], append([]int {4,5,6},slice2[3:]...)...)
fmt.Println(slice2)

copy( destSlice, srcSlice []T) int

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只會復(fù)制slice1的前3個元素到slice2中
fmt.Println(slice2)
// output
[1 2 3]

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice1, slice2) // 只會復(fù)制slice2的3個元素到slice1的前3個位置
fmt.Println(slice1)
// output
[5 4 3 4 5]

// 通過循環(huán)的方式演示切片
slice1 := make([]int, 2, 110)
slice2 := make([]int, 2, 110)
slice1[0] = 1
slice1[1] = 2
slice2[0] = 5
fmt.Println(slice1)// [1 2]
fmt.Println(slice2)// [5 0]


// 將切片1復(fù)制到切片2
for i := 0; i < 2; i++ {
		slice2[i] = slice1[i]
}
fmt.Println(slice2)// [1 2]
// 將切片2復(fù)制到切片1
for i := 0; i < 2; i++ {
		slice1[i] = slice2[i]
}
fmt.Println(slice1)// [5 0]

package main
import "fmt"
func main() {
    // 設(shè)置元素?cái)?shù)量為1000
    const elementCount = 1000
    // 預(yù)分配足夠多的元素切片
    srcData := make([]int, elementCount)
    // 將切片賦值
    for i := 0; i < elementCount; i++ {
        srcData[i] = i
    }
    // 引用切片數(shù)據(jù)
    refData := srcData
    // 預(yù)分配足夠多的元素切片
    copyData := make([]int, elementCount)
    // 將數(shù)據(jù)復(fù)制到新的切片空間中
    copy(copyData, srcData)
    // 修改原始數(shù)據(jù)的第一個元素
    srcData[0] = 999
    // 打印引用切片的第一個元素
    fmt.Println(refData[0])
    // 打印復(fù)制切片的第一個和最后一個元素
    fmt.Println(copyData[0], copyData[elementCount-1])
    // 復(fù)制原始數(shù)據(jù)從4到6(不包含)
    copy(copyData, srcData[4:6])
    for i := 0; i < 5; i++ {
        fmt.Printf("%d ", copyData[i])
    }
}

// 刪除切片開頭元素
// 1.使用切片的截取方法
slice = []int{1, 2, 3}
slice = slice[1:] // 刪除開頭1個元素
slice = slice[N:] // 刪除開頭N個元素

// 2.使用切片中的append()函數(shù)
slice = []int{1, 2, 3}
slice = append(slice[:0], slice[1:]...) // 刪除開頭1個元素
slice = append(slice[:0], slice[N:]...) // 刪除開頭N個元素

// 3.使用切片的copy()函數(shù)
slice = []int{1, 2, 3}
slice = slice[:copy(slice, slice[1:])] // 刪除開頭1個元素
slice = slice[:copy(slice, slice[N:])] // 刪除開頭N個元素

// 刪除中間
slice = []int{1, 2, 3, ...}
slice = append(slice[:i], slice[i+1:]...) // 刪除中間1個元素
slice = append(slice[:i], slice[i+N:]...) // 刪除中間N個元素
slice = slice[:i+copy(slice[i:], slice[i+1:])] // 刪除中間1個元素
slice = slice[:i+copy(slice[i:], slice[i+N:])] // 刪除中間N個元素

// 刪除結(jié)尾
slice = []int{1, 2, 3}
slice = slice[:len(slice)-1] // 刪除尾部1個元素
slice = slice[:len(slice)-N] // 刪除尾部N個元素

// 刪除切片的指定位置
 seq := []string{"a", "b", "c", "d", "e"}
// 指定刪除位置
index := 2
// 查看刪除位置之前的元素和之后的元素
fmt.Println(seq[:index], seq[index+1:])
// 將刪除點(diǎn)前后的元素連接起來
seq = append(seq[:index], seq[index+1:]...)
fmt.Println(seq)

// 整型排序
sli := []int{1, 5, 3, 4}
sort.Ints(sli)
for index, value := range sli {
fmt.Println(index, value)
}
fmt.Println("---------------")
// 字符串排序
sliStr :=[]string{"lisi", "zhangsan", "bruce"}
sort.Strings(sliStr)
fmt.Println(sliStr)
fmt.Println("---------------")
// 浮點(diǎn)型排序
sliFloat := []float64{12.56, 12.12}
sort.Float64s(sliFloat)
fmt.Println(sliFloat)

// 創(chuàng)建一個整型切片，并賦值
slice := []int{10, 20, 30, 40}
// 迭代每一個元素，并顯示其值
for index, value := range slice {
    fmt.Printf("Index: %d Value: %d\n", index, value)
}
// output
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40