标签:style class blog code color 使用
一:数组
一:可变数组 定义:数组使用有序列表存储相同类型的多重数据。 格式: 第一种格式 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> ()
标签:style class blog code color 使用
原文地址:http://www.cnblogs.com/gcb999/p/3781891.html