一：数组
一：可变数组 定义：数组使用有序列表存储相同类型的多重数据。 格式： 第一种格式 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> ()