码迷,mamicode.com
首页 > 其他好文 > 详细

Swift入门篇-集合

时间:2014-06-21 11:10:54      阅读:178      评论:0      收藏:0      [点我收藏+]

标签: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> ()

 

 

 

 

 

 

 

Swift入门篇-集合,布布扣,bubuko.com

Swift入门篇-集合

标签:style   class   blog   code   color   使用   

原文地址:http://www.cnblogs.com/gcb999/p/3781891.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!