Swift入门篇-集合

一：数组

一：可变数组 

    定义：数组使用有序列表存储相同类型的多重数据。

   格式：

 第一种格式

   var  变量: 类型[] = [变量值，变量值,...]

第二种格式

   var    变量 ＝[变量值，变量值,...]

  说明：

1：[变量值，变量值...]  这样表示数组 ，前提是 变量值的类型必须一值。（和其他语言有所不同）

2：上面两种格式都是定义一个数组，数组中的变量值的类型必须一致

3：第一种格式定义的数组，是直接定义数组，第二种格式定义的数组 是编译器通过类型值推导出是数组格式 

注意点
1：常量关键字（let)  定义的数组，不可变数组是不能做任何修改，只能访问。

2：变量关键字（var) 定义的数组 ，可变数组可以修改，可以访问。

例子

//-------数组的定义------------

/*
1：["hello","swift"] -->[]里面包含的变量值类型都是字符串，即是字符串可变数组
2；编译器通过["hello","swift"]  来推断 arr变量的类型是字符串可变数组类型
*/

var  arr = ["hello","swift"]

/*
1：var  arr1:String[]--->直接定义arr1 是字符串可变数组类型，其数组中值必须为字符串
*/
var  arr1:String[] =  ["hello","swift"]

println("arr =(arr),  arr1=(arr1)")

运行结果

arr =[hello, swift],  arr1=[hello, swift]

注意点 

var  str = [" hellow",11]
println("str =(str)")

运行结果
str =(
    " hellow",
    11
)

/*
1：[" hellow",11] -->[] 变量值类型是字符串和整形，类型不一致，即不是数组
2：结果(" hellow",11) 是一个不可变数组
*/

可变数组的操作

 ①：数组的长度和数组变量值修改

//-----------数组的长度----

var  Arr = ["hell0","swift"]
var count  = Arr.count //count 属性 返回 数组的长度
println( "count=(count)")

//------------数组中变量值的修改------
var  str = [81,82,85]

str[2] = 83 //str[2] 指的是数组中索引为2的变量值即85  重新赋值为83
println("str=(str)")

运行结果：

count=2

str=[81, 82, 83]

②：可变数组的追加  +=  append

//-------数组的追加---appped()函数------------

var  arr = [1,2] //定义整形数组变量arr
arr.append(3)//append(3) 是在arr数组的尾端追加变量值3到数组中  即数组长度增加1

println(" arr = (arr)  长度＝(arr.count)")


//-------数组的追加--- +＝ ------------

var  arr1 = [10,11] //定义整形数组变量arr
arr1 += 12 // += 是在arr数组的尾端追加变量值3到数组中 数组长度增加1 （内部实现原理 也会用到append函数）
println(" arr1= (arr1) 长度＝(arr1.count)")


运行结果

 arr = [1, 2, 3]  长度＝3
 arr1= [10, 11, 12] 长度＝3

③: 可变数组的插入　Insert(变量值 , atIndex: 索引)

//-------数组的追加 --- Insert(变量值 ,atIndex:索引）-----------

var  arr2 = [10,11]
arr2.insert(9,atIndex:0) // 在数组arr中0的位置插入变量值9 数组长度加1
println("arr2=(arr2) 长度＝(arr2.count)")

运行结果

arr2=[9, 10, 11] 长度＝3

3: 可变数组的移除  removeAtIndex（索引）,removeLast()

//--------------数组的移除  removeLast() 数组尾端移除变量值----

var arr4 = [200,201,202]

arr4.removeLast() //移除数组arr3中尾端的 的变量值，数组长度减1
println(" arr4 =(arr4)  长度＝(arr4.count)")



//--------------数组的移除  removeAtIndex（索引）数组指定位置移除变量值----

var arr3 = [100,101,102]

arr3.removeAtIndex(0)//移除数组arr3中索引为0 的变量值，数组长度减1
println("arr3 =(arr3)  长度＝(arr3.count)")


运行结果
 arr4 =[200, 201]  长度＝2
arr3 =[101, 102]  长度＝2

 4:创建空数组

①：定义可变空数组
格式：
 变量关键字  变量  ＝ 类型[] ()

例子： var  arr = Int[]()

注意点：
 1：常量关键字(let) 修辞的数组是不可变数组，不能修改，定义空字符数组没有意义
 2：变量关键字(var） 修辞的数组，是可变数组  实在是能动态改变的。

②：IsEmpty 函数判断数组是否为空

//-----------空数组----

/*
1: Int[] () 是整形空数组
2: arr 数组变量 被let 修辞 ，arr数组只能访问
*/

let  arr = Int[] ()


/*
1: Int[] () 是整形空数组
2: arr1 数组变量 被var  修辞 ，arr数组是可变数组，可以动态修改
*/
var arr1 = Int[] ()
arr1 += 1
println("arr1= (arr1)")

//-----------判断数组是否为空---
var arr2 = Int[] ()

if arr2.isEmpty { //isEmpth 是判断数组是否是空数组
    println("arr2 数组为空")
}
else{
        println("arr2 数组不为空")
}


运行结果

arr1= [1]
arr2 数组为空

 数组的遍历  for  in (前面文章讲过用法）

//------------数组的访问--  for  in -----

var arr = ["hello","swift"]

for str in arr {  //  for  变量 in 集合 当执行for  in的时候 集合中变量值会依次赋值给str
    
    println(str)
}

运行结果：

hello
swift

二：可变字典

一：可变字典

    定义：字典是一种存储相同类型多重数据的存储器。每个值（value）都关联独特的键（key），键作为字典中的这个值数据的标识符

   格式：

 第一种格式

   变量  变量: Dictionary<类型,类型> = [变量值:变量值，变量值:变量值,...]

第二种格式

   变量   变量 ＝[变量值:变量值，变量值：变量值,...]

  说明：
例子：
第一种格式：

var  dic:Dictionary<String ,Int>= ["H1":1,"H2":2]

第二种格式：

var  dic = ["H1":1,"H2":2]

说明：
字典规范  
1：[]中由 key:value 键值组成的  

2：所有key 的类型必须一直， 所有value的类型必须一致，所有key不能重复

3：第一种格式定义的字典，是直接定义字典，第二种格式定义的数组 是编译器通过类型值推导出是字典格式 

注意点：

1：常量关键字（let)  定义的字典，是不可字典，是不能做任何修改，只能访问。

2：变量关键字（var) 定义的字典 ，是可变字典，是可以修改，可以访问。

例子：

/*
1: [] 里面有key:value组成
2: 所有key的类型一直并且不重复，所有value类型一致
3：即 ["H1":1 ,"H2":2] 是一字典类型 ，编译器通过字典类型推导出 dic是可变字典
*/

var  dic = ["H1":1 ,"H2":2]
println("dic=(dic)")

/*
1:var dic1:Dictionary<String ,Int>  直接定义可变字典类型中key 为字符串 value 为整形
2：key中字符不能重复
*/

var dic1:Dictionary<String ,Int> = ["H1":1 ,"H2":2]

println("dic1=(dic1)")

运行结果

dic=[H1: 1, H2: 2]
dic1=[H1: 1, H2: 2]

注意点：

/*
1：[] 是有key:value 组成
2：key 类型一直，不重复，但是value 类型不一致即是不可变字典

*/


var  str = ["str":1 ,"hell0":"swift"]

println(str)

 可变字典  修改值

1：updateValue(修改值, forKey key值）

2：通过[key] 来修改value 的值

//-------------通过key来修改value---updateValue(修改值, forKey  key值）

/*
1：[] 是有key:value 组成
2：key 类型一致，不充分是value 类型一致即是可变字典
*/
var  str = ["str":"aa" ,"hell0":"swift"]
str.updateValue("bb" ,forKey:"str")
println("str =(str)")


//-------------通过key来修改value---同[key]来修改value 的值

var  str1 = ["str":"aa" ,"hell0":"swift"]
str1["str"] = "cc" //字典同key（str)　直接修改key对应value
println("str1=(str1)")


运行结果：
str =[str: bb, hell0: swift]

str1=[str: cc, hell0: swift]

可变字典 -- 通过key　得到value的值 即value的是一个可选值。

/*
1：[] 是有key:value 组成
2：key 类型一致，不充分是value 类型一致即是可变字典

*/

var  str = ["str":"aa" ,"hell0":"swift"]
var temp = str["Str"]  //访问字典不存在的key ,返回值为nil
var temp1 = str["str"] //访问字典存在的key,返回对应的value
println("temp=(temp),temp1 = (temp1)")

// 总结 str[key] 返回值可能是正确，也有可能是返回nil  即 str[key] 返回值是可选值

运行结果;
temp=nil,temp1 = aa

字典的遍历  ----for  in 

var  dic = ["hello":1 , "swift":2]

//  for  元组  in  字典集合  用元组来表示字典中对应的键值

for (key,value) in dic {
    
    println("key=(key),value=(value)")
}

创建一个空的可变字典

格式 ： 
  var  变量 = Dictionary<key类型，value类型（）

//创建一个key为字符串　value　为整形的空字典，并且字典为可变字典
var arr = Dictionary<String,Int> ()