Go语言基础笔记（二）数组、切片、映射与结构体

1、数组

Go的数组与Java的数组基本上相同。

func main() {
	makeArray()
}
 
// 创建并给数组赋值
func makeArray() {
	//声明一个长度为2的字符串数组
	var sports [2]string
	fmt.Println(sports)
	//给数组的赋值
	sports[0] = "football"
	sports[1] = "basketball"
	fmt.Println(sports)
}

打印出来的效果：

2、切片

 切片可以理解为可以添加值的数组。

2.1、创建切片并赋值：

func main() {
	makeSlice()
}
 
// 创建切片
func makeSlice() {
	//初始化切片
	var sports = make([]string, 2)
	sports[0] = "football"
	sports[1] = "basketball"
	fmt.Println(sports)
}

打印出来的效果：

 2.2、创建切片并通过append插入切片：

func main() {
	sports := appendSlice()
	fmt.Println(sports)
}
 
// 创建切片通过append赋值
func appendSlice() []string {
	//初始化切片
	var sports = make([]string, 0)
	//fmt.Println(sports)
	//添加元素
	sports = append(sports, "football")
	sports = append(sports, "basketball")
	sports = append(sports, "volleyball", "table-tennis")
 
	return sports
}

2.3、删除指定位置的元素：

func main() {
	sports := appendSlice()
	fmt.Println(sports)
	fmt.Println(removeSlice(1,sports))
}
 
// 删除指定位置的元素
/**
	delIndex:删除位置
	slice:待删除的切片
 */
func removeSlice(delIndex int, slice []string) []string {
	slice = append(slice[:delIndex], slice[delIndex+1:]...)
	return slice
}

打印出来的效果：

2.4、拷贝切片，修改拷贝后的切片里的元素，不会影响原来的切片：

func main() {
	copySlice()
}
 
// 切片拷贝
func copySlice() {
	sports := make([]string, 2)
	sports[0] = "football"
	sports[1] = "basketball"
 
	newSports := make([]string, 2)
	copy(newSports, sports)
	fmt.Println(newSports)
}

 打印出来的效果：

 3、映射

映射与Java中的map基本相同，以键值对形式存储数据。

3.1、 创建映射并赋值：

func main() {
	makeMap()
}
 
// 映射，map键值对
func makeMap() {
	var players = make(map[string]int)
	players["James"] = 6
	players["Tatum"] = 0
	players["Brown"] = 7
 
	fmt.Println(players["Tatum"])
	fmt.Println(players["Brown"])
	fmt.Println(players)
}

打印出来的效果：

3.2、根据键名删除映射中的元素：

func main() {
	deleteMapEle()
}
 
// 删除映射中的元素
func deleteMapEle() {
	var players = make(map[string]int)
	players["James"] = 6
	players["Tatum"] = 0
	players["Brown"] = 7
 
	fmt.Println(players)
	delete(players, "James")
	fmt.Println(players)
}

打印出来的效果：

4、结构体

结构体类似于Java的对象

 4.1、创建一个结构体： 

// Player 创建一个结构体
//
//	type 类型名 struct {
//		字段名 字段类型
//		字段名 字段类型
//		…
//	}
type Player struct {
	Name   string
	Age    string
	Height string
}

4.2、声明结构体的三个方式：

func main() {
	newStruct1()
	newStruct2()
	newStruct3()
}
 
// 声明结构体1
func newStruct1() {
	player := Player{
		Name:   "Tatum",
		Age:    "24y",
		Height: "2.03m",
	}
	fmt.Println(player)
	fmt.Println(player.Name)
	fmt.Println(player.Age)
	fmt.Println(player.Height)
}
 
// 声明结构体2
func newStruct2() {
	var player Player
 
	player.Name = "Brown"
	player.Age = "25y"
	player.Height = "1.98m"
 
	fmt.Println(player)
	fmt.Println(player.Name)
	fmt.Println(player.Age)
	fmt.Println(player.Height)
}
 
// 声明结构体3
func newStruct3() {
	player := new(Player)
	player.Name = "Smart"
	player.Age = "28y"
	player.Height = "1.93m"
 
	fmt.Println(player)
}

打印出来的效果：

4.3、修改结构体的值：

func main() {
	changeValue()
}
 
// 修改结构体的值
func changeValue() {
	var player Player
 
	player.Name = "Brown"
	player.Age = "25y"
	player.Height = "1.98m"
	fmt.Println(player.Age)
	player.Age = "26y"
	fmt.Println(player.Age)
}

 打印出来的效果：

4.4、嵌套结构体：

func main() {
	nestingStruct()
}
 
// 嵌套结构体
func nestingStruct() {
	type Team struct {
		Name string
		Home string
	}
 
	type Player struct {
		Name string
		Age  string
		Team Team
	}
 
	var player Player
	player.Name = "Tatum"
	player.Age = "24y"
	player.Team.Home = "Boston"
	player.Team.Name = "Celtics"
 
	fmt.Println(player)
}

 打印出来的效果：

 4.5、比较两个结构体:

只有两个结构体的所有值相等，才算相等

func main() {
	compareStruct()
}
 
// 比较两个结构体是否相等
func compareStruct() {
	var player1 Player
	player1.Name = "James"
	player1.Age = "38y"
 
	var player2 Player
	player2.Name = "James"
	player2.Age = "38y"
 
	var player3 Player
	player3.Name = "James"
	player3.Age = "37y"
 
	if player1 == player2 {
		fmt.Println("player1 and player2 are the same")
		fmt.Println("player1:", player1)
		fmt.Println("player2:", player2)
	}
 
	if player1 == player3 {
		fmt.Println("player1 and player3 are the same")
	} else {
		fmt.Println("player1 and player3 are not the same")
	}
	fmt.Println("player1:", player1)
	fmt.Println("player3:", player3)
}

打印出来的效果：

4.6、值引用

值引用不会改变原来结构体的值:

func main() {
	valueReference()
}
 
// 值引用
func valueReference() {
	var player1 Player
	player1.Name = "James"
	player1.Age = "38y"
 
	player2 := player1
	player2.Age = "37y"
	fmt.Println("player1", player1)
	fmt.Println("player2", player2)
}

打印出来的效果：

4.7、指针引用

指针引用会改变原来结构体的值:

func main() {
	pointReference()
}
 
// 指针引用
func pointReference() {
	var player1 Player
	player1.Name = "James"
	player1.Age = "38y"
 
	player2 := &player1
	player2.Age = "37y"
	fmt.Println("player1", player1)
	fmt.Println("player2", player2)
}

 打印出来的效果：