文章由作者马志国在博客园的原创,若转载请于明显处标记出处:http://www.cnblogs.com/mazg/

数组是由同构的元素组成。结构体是由异构的元素组成。数据和结构体都是有固定内存大小的数据结构。相比之下,切片和映射则是动态的数据结构,它们根据需要动态增长。

4.1 数组

数组是一系列同一类型数据的集合,数组中包含的每个数据被称为数组元素。一个数组包含的元素个数称为数组的长度,数组长度是固定的。一个数组可以由零个或多个元素组成。

1 数组声明

数组声明的一般形式:

var 数组名 [长度]类型

示例如下:

var arr [10]int           //10个元素的整型数组

var ptrs [5]*float64  //5个元素的指针数组,每个指针都指向float64类型

var points [8]struct{ x, y int }  //8个元素的结构体类型

var arry [2][3]int               //2*3的二维整型数组

2 简短声明

与变量的简短声明一样,数组也可以简短声明。如果在数组的长度位置出现的是“...”省略号,则表示数据的长度是根据初始化值得个数来计算。

a := [3]int{1, 2, 3} // 长度为3的数组

b := [5]int{1, 2, 3} //长度为10,前三个元素为1、2、3,其它默认为0

c := [...]int{4, 5, 6} //长度3的方式,Go自动计算长度

r := [...]int{9: 6}    //长度为10,最后一个元素的值为6,其它默认为0

arr2 := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}//二维数组

3 元素访问

数组的每个元素通过索引下标来访问,内置的len函数将返回数组中元素的个数。

arr := [...]int{1, 2, 3, 4, 5}

len := len(arr)   //len获取数组长度

fmt.Println("修改前:", arr)

arr[0] = 100      //下标访问数组元素

fmt.Println("修改后:", arr)

fmt.Println("数组长度:", len)

打印结果:

修改前: [1 2 3 4 5]

修改后: [100 2 3 4 5]

数组长度: 5

4 数组遍历

两种遍历方式,其中range表达式遍历有两个返回值,第一个是索引,第二个是元素的值。示例如下:

arr := [...]int{1, 2, 3, 4, 5}

len := len(arr) //len获取数组长度

for i := 0; i < len; i++ {

fmt.Println(i, arr[i])

}

for i, v := range arr {

fmt.Println(i, v)

}

5 作为函数参数

在Go语言中,数组作为函数的参数仍然是值传递,虽然可以使用数组的指针来代替,但是改变不了数组长度。这时,我们通常使用切片slice来替代数组。

6 数组比较

如果数组元素的类型是可比较的,那么这个数组也是可的比较。只有数组的所有元素都相等数组才是相等的。由于长度也是数组类型的一部分,所以长度不同的数组是不等的。

数组可遍历、可修改,是否可比较,由数组元素决定。%T用于显示一个值对应的数据类型。

4.2 数组切片(slice)

数组的长度在定义之后无法修改。数组是值类型,每次传递都将产生一份副本。显然这无法满足开发者的某些需求。Go语言提供了数组切片(slice)来弥补数组的不足。数组和slice之间有着紧密的联系,一个slice是一个轻量级的数据结构,提供了访问数组子序列元素的功能,而且slice的底层确实引用一个数组对象。

1 声明数组切片(slice)

数组切片与数组声明非常相似,唯一区别是无需指定长度。

var 数组切片 []类型

var slice []int

2 基于数组以及基于切片创建切片

arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //数组

slice1 := arr[0:5]     //基于数组切片1,左闭右开

slice2 := slice1[1:3]  //基于切片1创建切片2

fmt.Println(slice1)    //[1 2 3 4 5]

fmt.Println(slice2)    //[2 3]

3 直接创建切片

Go语言提供的内置函数make()可以用于灵活的创建数组切片。make()函数创建一个指定元素类型、长度和容量的slice。容量部分可以省略,在这种情况下,容量将等于长度。在底层,make创建了一个匿名的数组变量,然后返回一个slice。只有通过返回的slice才能引用匿名的数组变量。

make([]T,len)

make([]T,len,cap)

内置的len()函数获取长度,内置的cap()函数获取容量。

slice1 := make([]int, 5)

slice2 := make([]int, 5, 10)

slice3 := []int{1, 2, 3, 4, 5}

fmt.Println(slice1, len(slice1), cap(slice1))

fmt.Println(slice2, len(slice2), cap(slice2))

fmt.Println(slice3, len(slice3), cap(slice3))

打印结果:

[0 0 0 0 0] 5 5

[0 0 0 0 0] 5 10

[1 2 3 4 5] 5 5

与数组相同,slice操作不能超出len指定的范围。

slice := make([]int, 5, 10)

slice[3] = 10 //正确

slice[8] = 8 //错误 ,索引超出范围

4 切片的遍历

切片的遍历与数组的遍历方式相同。

5 切片不能比较

与数组不同的是slice之间不能比较,因此我们不能使用==操作符来判断两个slice是否含有全部相等的元素。不过标准库提供了高度优化的bytes.Equal函数两个字节型slice是否相等,但是对于其它类型的slice,我们必须自己展开每个元素进行比较。

切片可遍历,可修改,不可比较

6 判断切片是否为空

使用len(s)==0来判断一个slice是否为空。

7 追加元素

内置的append函数用于向slice追加元素。可以直接追加元素,也可以追加一个slice。注意参数slice后有...。否则有语法错误。因为append()函数的语义是从第二个参数开始都应该是待附加的元素。slice后加...意味将slice的元素全部打散后传入。数组切片会自动处理存储空间不足的问题。如果追加的内容长度超过当前已分配的存储空间(即cap()调用返回的信息),数组切片会自动分配一块足够大的内存。

slice := make([]int, 5, 10)

slice = append(slice, 1, 2, 3)

fmt.Println(slice)

slice2 := []int{4, 5, 6}

slice = append(slice, slice2...)

fmt.Println(slice)

打印结果:

[0 0 0 0 0 1 2 3]

[0 0 0 0 0 1 2 3 4 5 6]

8 切片复制

内置的copy函数用于数组切片的复制。复制时无需考虑目标数组和源数组的长度。

slice1 := []int{1, 2, 3, 4, 5}

slice2 := []int{7, 8, 9}

copy(slice2, slice1) //只会将slice1的前3个元素赋值给slice2

fmt.Println(slice2)

slice3 := []int{1, 2, 3, 4, 5}

slice4 := []int{7, 8, 9}

copy(slice3, slice4) //将slice4的元素赋值slice3的前3个元素

fmt.Println(slice3)

打印结果:

[1 2 3]

[7 8 9 4 5]

9 作为函数参数时切片与数组的区别

func SetValueByArray(arr [5]int) {

arr[0] = 100

}

func SetValueBySlice(slice []int) {

slice[0] = 100

}

func main() {

arr := [5]int{1, 2, 3, 4, 5}

SetValueByArray(arr)

fmt.Println(arr)

slice := arr[:]

SetValueBySlice(slice)

fmt.Println(arr)

}

//打印结果:

[1 2 3 4 5]

[100 2 3 4 5]

10字符串和byte切片

标准库中提供了4个与字符串操作相关的包:

功能

strings

提供了字符串查询、替换、比较、截断、拆分和合并等功能。

bytes

提供了很多与strings包类似的功能。因为字符串是只读的,逐步构建字符串会导致很多分配和复制,这种情况下,使用bytes.Buffer类型将会更有效。

strconv

提供了布尔类型、整数、浮点数和对应字符串的相互转换,还提供了双引号转义相关的转换。

unicode

提供了IsDigit、IsLetter、IsUpper和IsLower等功能,用于给字符分类。

strings包常用的6个函数,功能参考Go中文帮助文档

func Contains(s, substr string) bool

func Count(s, sep string) int

func Fields(s string) []string

func HasPrefix(s, prefix string) bool

func Index(s, sep string) int

func Join(a []string, sep string) string

byte包常用的的6个函数,功能与strings类似。

func Contains(b, subslice []byte) bool

func Count(s, sep []byte) int

func Fields(s []byte) [][]byte

func HasPrefix(s, prefix []byte) bool

func Index(s, sep []byte) int

func Join(s [][]byte, sep []byte) []byte

它们之间的唯一区别就是字符串类型的参数替换成了字节slice类型的参数。

4.3 映射

映射是一个无序的键值对集合,其中所有的键都是不同的,然后通过给定的键可以在常数时间复杂度内检索、更新或删除对应的值。在Go语言中,一个map就是一个哈希表的引用,映射中所有的键都有相同的类型,所有的值也有着相同的类型,但是键和值之间可以是不同的数据类型。

1 声明映射

声明的一般格式为:

var 映射名称 map[键]值

只是声明一个map,它的初始值是nil,也就是没有引用任何哈希表。所以不能向一个nil值的map存入元素。

var ages map[string]int

fmt.Println(age == nil)//”true”

fmt.Println(len(ages)== 0)//”true”

  2 创建映射

内置的make函数可以创建一个map,创建后可以存入元素。

myMap1 := make(map[string]int)      //创建一个map

myMap2 := make(map[string]int, 100) //创建一个map,初始储存能力为100

myMap3 := map[string]int{

"str1": 10, "str2": 20, "str3": 30} //直接创建,并初始化

fmt.Println(myMap1, len(myMap1))

fmt.Println(myMap2, len(myMap2))

fmt.Println(myMap3, len(myMap3))

打印结果:

map[] 0

map[] 0

map[str3:30 str1:10 str2:20] 3

3  元素的赋值和删除

  元素可以直接赋值,内置的delete函数用于删除元素,删除一个不存在的元素,不会造成错误。

myMap3 := map[string]int{"str1": 10, "str2": 20, "str3": 30}

fmt.Println(myMap3, len(myMap3))

myMap3["str5"] = 50

fmt.Println(myMap3, len(myMap3))

delete(myMap3, "str")

delete(myMap3, "str3")

fmt.Println(myMap3, len(myMap3))

打印结果:

map[str3:30 str1:10 str2:20] 3

map[str5:50 str1:10 str2:20 str3:30] 4

map[str1:10 str2:20 str5:50] 3

 

4 查找元素

有时候可能需要知道对应的元素是否在map中,例如,如果元素类型是一个布尔类型,你可能需要区分一个零值的元素,和因为元素不存在而返回的零值,可以像下面这样使用:

v,ok:=map[key]

if !ok{/*在map中不存在key为键的元素*/}

//结合起来使用

if v,ok:=map[key];!ok{/*    */ }

在这种场景下,map下标语法将产生两个值;第二个值是一个布尔类型,用于表示元素是否存在。布尔变量一般命名为ok。示例如下:

myMap3 := map[string]int{"str1": 10, "str2": 20, "str3": 30}

if v, ok := myMap3["str2"]; ok {

fmt.Println(v)

}

5 遍历映射

遍历map使用range风格的for循环实现。由于map是无序的集合,所以每次遍历的顺序可能不一样。

myMap3 := map[string]int{"str1": 10, "str2": 20, "str3": 30}

for k, v := range myMap3 {

fmt.Println(k, v)

}

6 映射不可比较

和slice一样,map之前也不能进行相等比较;唯一的例外是和nil进行比较。要判断两个map是否包含相同的key和value,我们必须通过一个循环实现。有时候,我们需要一个map的key是slice类型,但是map的key必须是可比较的类型,但是slice并不满足这个条件。我们可以通过两个步骤绕过这个限制。第一步,定义一个辅助函数k,将slice转为map对应的string类型的key,确保只有x和y相等时,k(x)==k(y)才成立。然后创建一个key为string类型的map,在每次对map操作时,先用k辅助函数将slice转化为string类型。

7 不能对映射元素取址操作

map中的元素并不是一个变量,不能对map元素进行取址操作。禁止对map元素取址的原因是map可能随着元素数量的增长而重新分配更大的内存空间,从而可能导致之前的地址无效。slice元素可以取址操作。

fmt.Println(&myMap3["str1"])//错误,不能取址操作

8 nil值映射

map上的大部分操作,包括查找、删除、len和range循环都可以安全工作在nil值的map上,它们的行为和一个空map类似。但是向一个nil值的map存入元素将导致一个panic异常。

数组是由同构的元素组成。结构体是由异构的元素组成。数据和结构体都是有固定内存大小的数据结构。相比之下,切片和映射则是动态的数据结构,它们根据需要动态增长。

4.1 数组

数组是一系列同一类型数据的集合,数组中包含的每个数据被称为数组元素。一个数组包含的元素个数称为数组的长度,数组长度是固定的。一个数组可以由零个或多个元素组成。

1 数组声明

数组声明的一般形式:

var 数组名 [长度]类型

示例如下:

var arr [10]int           //10个元素的整型数组

var ptrs [5]*float64  //5个元素的指针数组,每个指针都指向float64类型

var points [8]struct{ x, y int }  //8个元素的结构体类型

var arry [2][3]int               //2*3的二维整型数组

2 简短声明

与变量的简短声明一样,数组也可以简短声明。如果在数组的长度位置出现的是“...”省略号,则表示数据的长度是根据初始化值得个数来计算。

a := [3]int{1, 2, 3} // 长度为3的数组

b := [5]int{1, 2, 3} //长度为10,前三个元素为1、2、3,其它默认为0

c := [...]int{4, 5, 6} //长度3的方式,Go自动计算长度

r := [...]int{9: 6}    //长度为10,最后一个元素的值为6,其它默认为0

arr2 := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}//二维数组

3 元素访问

数组的每个元素通过索引下标来访问,内置的len函数将返回数组中元素的个数。

arr := [...]int{1, 2, 3, 4, 5}

len := len(arr)   //len获取数组长度

fmt.Println("修改前:", arr)

arr[0] = 100      //下标访问数组元素

fmt.Println("修改后:", arr)

fmt.Println("数组长度:", len)

打印结果:

修改前: [1 2 3 4 5]

修改后: [100 2 3 4 5]

数组长度: 5

4 数组遍历

两种遍历方式,其中range表达式遍历有两个返回值,第一个是索引,第二个是元素的值。示例如下:

arr := [...]int{1, 2, 3, 4, 5}

len := len(arr) //len获取数组长度

for i := 0; i < len; i++ {

fmt.Println(i, arr[i])

}

for i, v := range arr {

fmt.Println(i, v)

}

5 作为函数参数

在Go语言中,数组作为函数的参数仍然是值传递,虽然可以使用数组的指针来代替,但是改变不了数组长度。这时,我们通常使用切片slice来替代数组。

6 数组比较

如果数组元素的类型是可比较的,那么这个数组也是可的比较。只有数组的所有元素都相等数组才是相等的。由于长度也是数组类型的一部分,所以长度不同的数组是不等的。

数组可遍历、可修改,是否可比较,由数组元素决定。%T用于显示一个值对应的数据类型。

4.2 数组切片(slice)

数组的长度在定义之后无法修改。数组是值类型,每次传递都将产生一份副本。显然这无法满足开发者的某些需求。Go语言提供了数组切片(slice)来弥补数组的不足。数组和slice之间有着紧密的联系,一个slice是一个轻量级的数据结构,提供了访问数组子序列元素的功能,而且slice的底层确实引用一个数组对象。

1 声明数组切片(slice)

数组切片与数组声明非常相似,唯一区别是无需指定长度。

var 数组切片 []类型

var slice []int

2 基于数组以及基于切片创建切片

arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //数组

slice1 := arr[0:5]     //基于数组切片1,左闭右开

slice2 := slice1[1:3]  //基于切片1创建切片2

fmt.Println(slice1)    //[1 2 3 4 5]

fmt.Println(slice2)    //[2 3]

3 直接创建切片

Go语言提供的内置函数make()可以用于灵活的创建数组切片。make()函数创建一个指定元素类型、长度和容量的slice。容量部分可以省略,在这种情况下,容量将等于长度。在底层,make创建了一个匿名的数组变量,然后返回一个slice。只有通过返回的slice才能引用匿名的数组变量。

make([]T,len)

make([]T,len,cap)

内置的len()函数获取长度,内置的cap()函数获取容量。

slice1 := make([]int, 5)

slice2 := make([]int, 5, 10)

slice3 := []int{1, 2, 3, 4, 5}

fmt.Println(slice1, len(slice1), cap(slice1))

fmt.Println(slice2, len(slice2), cap(slice2))

fmt.Println(slice3, len(slice3), cap(slice3))

打印结果:

[0 0 0 0 0] 5 5

[0 0 0 0 0] 5 10

[1 2 3 4 5] 5 5

与数组相同,slice操作不能超出len指定的范围。

slice := make([]int, 5, 10)

slice[3] = 10 //正确

slice[8] = 8 //错误 ,索引超出范围

4 切片的遍历

切片的遍历与数组的遍历方式相同。

5 切片不能比较

与数组不同的是slice之间不能比较,因此我们不能使用==操作符来判断两个slice是否含有全部相等的元素。不过标准库提供了高度优化的bytes.Equal函数两个字节型slice是否相等,但是对于其它类型的slice,我们必须自己展开每个元素进行比较。

切片可遍历,可修改,不可比较

6 判断切片是否为空

使用len(s)==0来判断一个slice是否为空。

7 追加元素

内置的append函数用于向slice追加元素。可以直接追加元素,也可以追加一个slice。注意参数slice后有...。否则有语法错误。因为append()函数的语义是从第二个参数开始都应该是待附加的元素。slice后加...意味将slice的元素全部打散后传入。数组切片会自动处理存储空间不足的问题。如果追加的内容长度超过当前已分配的存储空间(即cap()调用返回的信息),数组切片会自动分配一块足够大的内存。

slice := make([]int, 5, 10)

slice = append(slice, 1, 2, 3)

fmt.Println(slice)

slice2 := []int{4, 5, 6}

slice = append(slice, slice2...)

fmt.Println(slice)

打印结果:

[0 0 0 0 0 1 2 3]

[0 0 0 0 0 1 2 3 4 5 6]

8 切片复制

内置的copy函数用于数组切片的复制。复制时无需考虑目标数组和源数组的长度。

slice1 := []int{1, 2, 3, 4, 5}

slice2 := []int{7, 8, 9}

copy(slice2, slice1) //只会将slice1的前3个元素赋值给slice2

fmt.Println(slice2)

slice3 := []int{1, 2, 3, 4, 5}

slice4 := []int{7, 8, 9}

copy(slice3, slice4) //将slice4的元素赋值slice3的前3个元素

fmt.Println(slice3)

打印结果:

[1 2 3]

[7 8 9 4 5]

9 作为函数参数时切片与数组的区别

func SetValueByArray(arr [5]int) {

arr[0] = 100

}

func SetValueBySlice(slice []int) {

slice[0] = 100

}

func main() {

arr := [5]int{1, 2, 3, 4, 5}

SetValueByArray(arr)

fmt.Println(arr)

slice := arr[:]

SetValueBySlice(slice)

fmt.Println(arr)

}

//打印结果:

[1 2 3 4 5]

[100 2 3 4 5]

10字符串和byte切片

标准库中提供了4个与字符串操作相关的包:

功能

strings

提供了字符串查询、替换、比较、截断、拆分和合并等功能。

bytes

提供了很多与strings包类似的功能。因为字符串是只读的,逐步构建字符串会导致很多分配和复制,这种情况下,使用bytes.Buffer类型将会更有效。

strconv

提供了布尔类型、整数、浮点数和对应字符串的相互转换,还提供了双引号转义相关的转换。

unicode

提供了IsDigit、IsLetter、IsUpper和IsLower等功能,用于给字符分类。

strings包常用的6个函数,功能参考Go中文帮助文档

func Contains(s, substr string) bool

func Count(s, sep string) int

func Fields(s string) []string

func HasPrefix(s, prefix string) bool

func Index(s, sep string) int

func Join(a []string, sep string) string

byte包常用的的6个函数,功能与strings类似。

func Contains(b, subslice []byte) bool

func Count(s, sep []byte) int

func Fields(s []byte) [][]byte

func HasPrefix(s, prefix []byte) bool

func Index(s, sep []byte) int

func Join(s [][]byte, sep []byte) []byte

它们之间的唯一区别就是字符串类型的参数替换成了字节slice类型的参数。

4.3 映射

映射是一个无序的键值对集合,其中所有的键都是不同的,然后通过给定的键可以在常数时间复杂度内检索、更新或删除对应的值。在Go语言中,一个map就是一个哈希表的引用,映射中所有的键都有相同的类型,所有的值也有着相同的类型,但是键和值之间可以是不同的数据类型。

1 声明映射

声明的一般格式为:

var 映射名称 map[键]值

只是声明一个map,它的初始值是nil,也就是没有引用任何哈希表。所以不能向一个nil值的map存入元素。

var ages map[string]int

fmt.Println(age == nil)//”true”

fmt.Println(len(ages)== 0)//”true”

  2 创建映射

内置的make函数可以创建一个map,创建后可以存入元素。

myMap1 := make(map[string]int)      //创建一个map

myMap2 := make(map[string]int, 100) //创建一个map,初始储存能力为100

myMap3 := map[string]int{

"str1": 10, "str2": 20, "str3": 30} //直接创建,并初始化

fmt.Println(myMap1, len(myMap1))

fmt.Println(myMap2, len(myMap2))

fmt.Println(myMap3, len(myMap3))

打印结果:

map[] 0

map[] 0

map[str3:30 str1:10 str2:20] 3

3  元素的赋值和删除

  元素可以直接赋值,内置的delete函数用于删除元素,删除一个不存在的元素,不会造成错误。

myMap3 := map[string]int{"str1": 10, "str2": 20, "str3": 30}

fmt.Println(myMap3, len(myMap3))

myMap3["str5"] = 50

fmt.Println(myMap3, len(myMap3))

delete(myMap3, "str")

delete(myMap3, "str3")

fmt.Println(myMap3, len(myMap3))

打印结果:

map[str3:30 str1:10 str2:20] 3

map[str5:50 str1:10 str2:20 str3:30] 4

map[str1:10 str2:20 str5:50] 3

 

4 查找元素

有时候可能需要知道对应的元素是否在map中,例如,如果元素类型是一个布尔类型,你可能需要区分一个零值的元素,和因为元素不存在而返回的零值,可以像下面这样使用:

v,ok:=map[key]

if !ok{/*在map中不存在key为键的元素*/}

//结合起来使用

if v,ok:=map[key];!ok{/*    */ }

在这种场景下,map下标语法将产生两个值;第二个值是一个布尔类型,用于表示元素是否存在。布尔变量一般命名为ok。示例如下:

myMap3 := map[string]int{"str1": 10, "str2": 20, "str3": 30}

if v, ok := myMap3["str2"]; ok {

fmt.Println(v)

}

5 遍历映射

遍历map使用range风格的for循环实现。由于map是无序的集合,所以每次遍历的顺序可能不一样。

myMap3 := map[string]int{"str1": 10, "str2": 20, "str3": 30}

for k, v := range myMap3 {

fmt.Println(k, v)

}

6 映射不可比较

和slice一样,map之前也不能进行相等比较;唯一的例外是和nil进行比较。要判断两个map是否包含相同的key和value,我们必须通过一个循环实现。有时候,我们需要一个map的key是slice类型,但是map的key必须是可比较的类型,但是slice并不满足这个条件。我们可以通过两个步骤绕过这个限制。第一步,定义一个辅助函数k,将slice转为map对应的string类型的key,确保只有x和y相等时,k(x)==k(y)才成立。然后创建一个key为string类型的map,在每次对map操作时,先用k辅助函数将slice转化为string类型。

7 不能对映射元素取址操作

map中的元素并不是一个变量,不能对map元素进行取址操作。禁止对map元素取址的原因是map可能随着元素数量的增长而重新分配更大的内存空间,从而可能导致之前的地址无效。slice元素可以取址操作。

fmt.Println(&myMap3["str1"])//错误,不能取址操作

8 nil值映射

map上的大部分操作,包括查找、删除、len和range循环都可以安全工作在nil值的map上,它们的行为和一个空map类似。但是向一个nil值的map存入元素将导致一个panic异常。

第四章 go语言 数组、切片和映射的更多相关文章

  1. perl5 第四章 列表和数组变量

    第四章 列表和数组变量 by flamephoenix 一.列表二.数组--列表的存贮  1.数组的存取  2.字符串中的方括号和变量替换   3.列表范围  4.数组的输出  5.列表/数组的长度  ...

  2. GO语言学习(十四)Go 语言数组

    Go 语言数组 Go 语言提供了数组类型的数据结构. 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整形.字符串或者自定义类型. 相对于去声明number0 ...

  3. 《计算机网络》谢希仁(第7版) 第四章 c语言http://c.biancheng.net/cpp/html/3137.html

    第四章 网络层 电信网使用面向连接的通信方式,使电信网络能够向用户提供可靠传输的服务. 互联网设计思路:网络层向上只提供简单灵活的.无连接的.尽最大努力交付的数据报(分组)服务. 网络层不提供可靠传输 ...

  4. C语言编程入门之--第四章C语言基本数据类型

      导读:C语言程序中经常涉及一些数学计算,所以要熟悉其基本的数据类型.数据类型学习起来比较枯燥,不过结合之前的内存概念,以及本节的字节概念,相信数据类型也就不难理解了.本章从二进制的基本概念开始,然 ...

  5. C 语言入门---第六章 C语言数组

    数组就是一些列具有相同类型的数据的集合,这些数据在内存中一次挨着存放,彼此之间没有缝隙. 我们可以将二维数组看作一个Excel表格,有行有列,length1 表示行数,length2 表示列数,要在二 ...

  6. &lt;深入理解C指针&gt;学习笔记和总结 第四章 指针和数组

    数组是一个什么玩意: 数组和指针我的理解,有同样之处也有不同之处.因有同样之处,因此一些资料上说,数组和指针本质是同样的.因有不同之处,因此也有一些资料上说,数组和指针是不一样的. 同样之处: 数组名 ...

  7. 《利用python进行数据分析》读书笔记--第四章 numpy基础:数组和矢量计算

    http://www.cnblogs.com/batteryhp/p/5000104.html 第四章 Numpy基础:数组和矢量计算 第一部分:numpy的ndarray:一种多维数组对象 实话说, ...

  8. 《利用Python进行数据分析·第2版》第四章 Numpy基础:数组和矢量计算

    <利用Python进行数据分析·第2版>第四章 Numpy基础:数组和矢量计算 numpy高效处理大数组的数据原因: numpy是在一个连续的内存块中存储数据,独立于其他python内置对 ...

  9. GO语言数组和切片实例详解

    本文实例讲述了GO语言数组和切片的用法.分享给大家供大家参考.具体分析如下: 一.数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列. (1)数组的创建. 数组有3种创建方式: ...

随机推荐

  1. Android Studio怎样选择查看指定进程的log?

    今天说一个简单的东东,关于Android Studio在logcat中怎样查看指定进程的log. 关于过滤你自己所开发的应用的log.在这篇文章中:Android Studio怎样给log加入过滤项( ...

  2. poj 2570 Fiber Network(floyd)

    #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; int ...

  3. jquery 自定义选择器

    // HTML 代码 <body> <div id="divid1" class="divclass">白色</div> & ...

  4. mysql并行复制降低主从同步延时的思路与启示

    一.缘起 mysql主从复制,读写分离是互联网用的非常多的mysql架构,主从复制最令人诟病的地方就是,在数据量较大并发量较大的场景下,主从延时会比较严重. 为什么mysql主从延时这么大? 回答:从 ...

  5. Activiti 基本操作之“受理人变量”

    在 Activiti 流程引擎中,尽管通过 setAssignee(taskId, userId) 可以设置受理人,但这毕竟要先把下一步的任务查出来才能设置,比较繁琐:借助 Activiti 的 ac ...

  6. 阿里云ECS部署ZooKeeper注意事项

    如果ECS为专有网络+弹性IP时,配置集群中,"自己"的ip要写成0.0.0.0,其他服务器可以写成公网ip.否则会包如下错误: java.net.BindException: C ...

  7. lock锁速记

    1.Lock关键字主要实现锁互斥,确保一个线程A在请求此操作时不会被其线程B请求中断(假设A先请求并在没有未完成的操作情况下申请了此互斥锁).lock的参数必须是基于引用类型的对象,不要是基本类型像b ...

  8. attr设置checked,disabled等属性失效的问题,jquery的attr和prop的区别

    最近做项目遇到一个问题,radio设置了默认checked值,attr("checked",true)切换checked值失效 最后发现是jquery1.6版本之后,attr和pr ...

  9. 「mysql优化专题」你们要的多表查询优化来啦!请查收(4)

    一.多表查询连接的选择: 相信这内连接,左连接什么的大家都比较熟悉了,当然还有左外连接什么的,基本用不上我就不贴出来了.这图只是让大家回忆一下,各种连接查询. 然后要告诉大家的是,需要根据查询的情况, ...

  10. 《C程序设计语言》【PDF】下载链接:

    <C程序设计语言>[PDF]下载 https://u253469.pipipan.com/fs/253469-230382180 内容简介 在计算机发展的历史上,没有哪一种程序设计语言像C ...