一、数据结构

本文介绍: 数组切片哈希表字符串

一、数组

1.1 数组定义遍历

package main

import "fmt"

func main() {
	//array()
	traverse()
}

// 遍历数组 传递指针
func traverse() {
	var b = [...]int{1, 2, 3}   //长度为3 元素为 1 2 3
	var ptr = &b                //ptr是指向数组的指针
	fmt.Println(b[0], b[1])     // 打印数组的前 2 个元素
	fmt.Println(ptr[0], ptr[1]) // 通过数组指针访问数组元素的方式和数组类似
	//1.为了避免复制数组带来的开销，可以传递一个指向数组的指针
	//通过数组指针遍历
	for i, v := range ptr {
		fmt.Printf("a[%d]:%dn", i, v)
	}

	//2.第一种遍历方式 使用for range 迭代可以保证不会出现数组越界情况
	for i := range b {
		fmt.Printf("a[%d]:%dn", i, b[i])
	}
	//第二种遍历方式
	for i, v := range b {
		fmt.Printf("a[%d]:%dn", i, v)
	}
	//第三种遍历方式
	for i := 0; i < len(b); i++ {
		fmt.Printf("a[%d]:%dn", i, b[i])
	}
	fmt.Printf("---------------------------")

}

// 1.数组定义
func array() {
	var a [3]int                    //长度为3 全部为0
	var b = [...]int{1, 2, 3}       //长度为3 元素为 1 2 3
	var c = [...]int{2: 3, 1: 2}    //长度为3，元素为 0 2 3
	var d = [...]int{1, 2, 4: 5, 6} //长度为6 元素 1 2 0 0 5 6
	var g [0]int                    // 定义一个长度为 0 的数组
	var e = [0]int{}                // 定义一个长度为 0 的数组
	var f = [...]int{}              // 定义一个长度为 0 的数组
	fmt.Println(a, b, c, d, g, e, f)

}

二、切片

2.1

Cap 成员表示切片指向的内存空间的最大容量（对应元素的个数，而不是字节数）

package main

import "fmt"

func main() {
	slice()
}

// 定义 添加 删除
func slice() {
	var (
		_ []int               // nil 切片, 和 nil 相等, 一般用来表示一个不存在的切片
		_ = []int{}           // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
		c = []int{1, 2, 3}    // 有 3 个元素的切片, len 和 cap 都为 3
		d = c[:2]             // 有 2 个元素的切片, len 为 2, cap 为 3
		e = c[0:2:cap(c)]     // 有 2 个元素的切片, len 为 2, cap 为 3
		_ = c[:0]             // 有 0 个元素的切片, len 为 0, cap 为 3
		_ = make([]int, 3)    // 有 3 个元素的切片, len 和 cap 都为 3
		_ = make([]int, 2, 3) // 有 2 个元素的切片, len 为 2, cap 为 3
		_ = make([]int, 0, 3) // 有 0 个元素的切片, len 为 0, cap 为 3
	)
	fmt.Println(d, e)
	//1.末尾 添加操作
	//d = append(d, 1)       //1 2 1
	//d = append(d, 1, 2, 3) //1 2 1 2 3
	//d = append(d, []int{1, 2}...) //1 2 1 2
	d = append(d, e...) // 1 2 1 2
	fmt.Println("d:", d)

	//2.在切片开头添加元素 在开头一般都会导致内存的重新分配,从切片的开头添加元素的性能一般要比从尾部追加元素的性能差很多
	//e = append([]int{1}, e...)
	e = append([]int{-1, 0}, e...)
	fmt.Println("e:", e)

	// 3.中间插入 第二个 append 创建临时切片
	var a = []int{1, 2, 3, 4, 5}
	//a = append(a[:2], append([]int{0}, a[2:]...)...)//添加一个 1 2 0 3 4 5
	//a = append(a[:2], append([]int{0, 0}, a[2:]...)...) //添加切片
	fmt.Println("a:", a)
	// copy append 组合 避免创建临时切片
	//a = append(a, 0)   // 切片扩展 1 个空间
	//copy(a[3:], a[2:]) // a[i:] 向后移动 1 个位置
	//a[2] = 0           // 设置新添加的元素
	var A = []int{0, 0, 0}
	a = append(a, A...)       //扩展三个切片
	copy(a[2+len(A):], a[2:]) //后移三个空间
	copy(a[2:], A)            //复制新添加内容
	fmt.Println("a:", a)

	//4.删除-尾部
	a = []int{1, 2, 3}
	//a = a[:len(a)-1] //1 2 删除尾部一个元素
	a = a[:len(a)-2] //1  删除尾部2个元素
	// 删除-头部 移动指针
	a = []int{1, 2, 3}
	a = a[1:] //a[N:] 删除开头 N 个元素 len(a)=2, cap(a)=2
	// 删除-头部 不移动数据指针,不会导致内存空间结构变化
	a = []int{1, 2, 3}
	a = append(a[:0], a[1:]...) //删除开头1个元素 len(a)=2, cap(a)=3  append(a[:0], a[N:]...) 删除开头N个元素
	//删除-头部 copy
	a = []int{1, 2, 3}
	//a = a[:copy(a, a[1:])] //copy(a, a[1:])=2 删除开头 1 个元素  a[N:] 删除开头N个元素 元素为: 2 3
	a = a[:copy(a, a[2:])]

	//5.删除-中间 append
	a = []int{1, 2, 3, 4, 5}
	a = append(a[:2], a[3:]...) //append(a[:i], a[i+1:]...) 删除中间 1 个元素
	a = append(a[:2], a[4:]...) // append(a[:i], a[i+N:]...) 删除中间 N 个元素
	//删除-中间 copy
	a = []int{1, 2, 3, 4, 5}
	//a = a[:copy(a[1:], a[2:])+1] //删除中间 1 个元素 a = a[:i+copy(a[i:], a[i+1:])]
	a = a[:copy(a[1:], a[3:])+1] // 删除中间 n 个元素 a = a[:i+copy(a[i:], a[i+N:])]
	fmt.Println("删除:", a)
}

三、哈希表

四、字符串

4.1 定义

package main

import "fmt"

func main() {
	string()
}

func string() {
	s := "hello,world"
	/*
		1.字符串虽然不是切片，但是支持切片操作
	*/
	s1 := s[:5]             //hello
	s2 := s[6:]             //world
	s3 := "hello,world"[:5] //hello
	fmt.Println(s, s1, s2, s3, len(s3))
}