一：数组

 

一：可变数组     定义：数组使用有序列表存储相同类型的多重数据。   格式： 第一种格式   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  重新赋值为83println("str=\(str)")运行结果：count=2str=[81, 82, 83]

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

//-------数组的追加---appped()函数------------var  arr = [1,2] //定义整形数组变量arrarr.append(3)//append(3) 是在arr数组的尾端追加变量值3到数组中  即数组长度增加1println(" arr = \(arr)  长度＝\(arr.count)")//-------数组的追加--- +＝ ------------var  arr1 = [10,11] //定义整形数组变量arrarr1 += 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 数组长度加1println("arr2=\(arr2) 长度＝\(arr2.count)")运行结果arr2=[9, 10, 11] 长度＝3

 

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

//--------------数组的移除  removeLast() 数组尾端移除变量值----var arr4 = [200,201,202]arr4.removeLast() //移除数组arr3中尾端的 的变量值，数组长度减1println(" arr4 =\(arr4)  长度＝\(arr4.count)")//--------------数组的移除  removeAtIndex（索引）数组指定位置移除变量值----var arr3 = [100,101,102]arr3.removeAtIndex(0)//移除数组arr3中索引为0 的变量值，数组长度减1println("arr3 =\(arr3)  长度＝\(arr3.count)")运行结果 arr4 =[200, 201]  长度＝2arr3 =[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 += 1println("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)}运行结果：helloswift

 

二：可变字典

一：可变字典    定义：字典是一种存储相同类型多重数据的存储器。每个值（value）都关联独特的键（key），键作为字典中的这个值数据的标识符   格式： 第一种格式   变量  变量: Dictionary
     <类型,类型>
       = [变量值:变量值，变量值:变量值,...]第二种格式   变量   变量 ＝[变量值:变量值，变量值：变量值,...]  说明：例子：第一种格式：var  dic:Dictionary
      
       = ["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
     
        直接定义可变字典类型中key 为字符串 value 为整形2：key中字符不能重复*/var dic1:Dictionary
      
        = ["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对应valueprintln("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 ,返回值为nilvar temp1 = str["str"] //访问字典存在的key,返回对应的valueprintln("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　为整形的空字典，并且字典为可变字典var arr = Dictionary
     
       ()