swift 有序字典

2018-03-02 16:48:47 grl18840839630 阅读数 859

//1 数组:存放统一数据类型元素

//1)、创建一个带类型的空数组(Int):

var array = [Int]()

array = [12,5,6]

//string数组)

var arrStr = [String]()

arrStr = ["sdfsdf","sfsdfsdf","sdfsdf"]

// 2)、错误类型

//array = ["sdfd",2324,"sdfsdfdfs"] 存放统一类型数据



//var arreroor = [Int](12,45,66)

var arreroor = [Int](arrayLiteral: 12,45,66)

var arrvalue:[String] = ["sdfsdf","sdfdsf","sdfsdfsdf"]


//3)、带着默认值和长度限制的数组:

var limateArr = Array(repeating:0.0,count:4)

print(limateArr)


//4)数组合并使用+号做数组合并

arrStr + arrvalue

//arrvalue + arreroor//类型不匹配(string + Int

String(describing: arrvalue) + String(describing: arreroor)


//5)、数组的访问:

print("这个数组的元素个数是:\(arrvalue.count)")

//6)、数组是否为空:

var emptyArr = [Int]()

if emptyArr.isEmpty {

    print("is empty!")

}else{

    print("is not empty!")

}


//(7)、拼接,添加 拼接到数组元素结尾

emptyArr.append(12)

print(emptyArr)

//8)、使用+=做拼接

arrvalue += ["sdfsdf","dfgdfghfghfgh"]


//arrvalue += [1,45,5]//类型不匹配

//arreroor += 12 //类型不匹配


//9)、下表访问:

arreroor += [12,343,566]

arreroor[1]

arreroor[0]


for number in arreroor {

    print(number)

}


//(10)、替换

arrvalue[1...4] = ["a","b"]

print(arrvalue)


//11)、插入:insert

arrvalue.insert("2", at: 1)

arrvalue.insert(String(2), at: 1)


print(arrvalue)

//12)、移除remove,根据索引移除

arrvalue.remove(at: 0)

arrvalue.removeLast()

arrvalue.removeFirst()

arrvalue.removeAll()


//13)、便利值和索引:

for (index,value) in arreroor.enumerated(){

    print("元素的索引是:\(index),元素值是:\(value)")

}


//二、set 装无序的同一类型的元素,元素不能重复

//(1)、集合的创建

var lettileset = Set<String>()//创建空集合

print("集合的长度是:\(lettileset.count)")

//(2)、集合赋值

lettileset = ["sdsfsf","sdfsdf","dfdfgdfg","sdsfsf"]

lettileset = []

//(3)、集合特点

//同一集合中不会存在相同元素,存在相同元素不会报错

var intSet = Set<Int>()

intSet = [1,4,5,5]

//(4)、集合元素添加

//intSet.insert("sdfds")//类型不匹配

intSet.insert(2)//元素无序

print(intSet)

//intSet[0]取发错误


// 作业:写一个字符串类型的数组和集合,里面分别包含4个元素(区别一下数组和集合)


var noneTypeSet:Set = ["sdfsdf","dfdfgdf"]

//注意:

//var noneType:Set = []//写发错误

//var nonetype = Set()//写发错误


//5)、集合的长度:

print("\(noneTypeSet.count)")


//6)、集合是否为空:

if noneTypeSet.isEmpty{

    print("空集合")

}else{

    print("非空集合")

}


//7)、插入(insert

noneTypeSet.insert("adddddd")


//8)、移除:remove()

noneTypeSet.remove("adddddd")

noneTypeSet.removeFirst()

//noneTypeSet.removeAll()


//9)、是否包含:

if noneTypeSet.contains("dfdfgdf"){

    print("存在")

}else{

    print("不存在")

}




//10)、集合的便利:


noneTypeSet.insert("age")

noneTypeSet.insert("zhang")


for value in noneTypeSet{

    print("\(value)")

}


//11)、返回有序数组

var oderArr = noneTypeSet.sorted()

print(oderArr)


//Int型的集合:

var intValueSet = Set<Int>(arrayLiteral: 1,3,5,7,3,2,1)

intValueSet = [23,454,23,545,13233]


var newIntSet = intValueSet.sorted()

print(newIntSet)



var valueqq:Set = [1,2,3,4,5]

var valueName:Set  = [4,5,6]



//12、使用原有集合根据条件创建新的集合:

//使用两个集合都存在的值创建一个新的集合

var newValue = valueqq.intersection(valueName)

print(newValue)


//在一个集合中,但不在两个集合中,(除了两个集合共有的元素以外的元素)

var newSet = valueqq.symmetricDifference(valueName)

print(newSet)


//合并,出去元素中重复的元素

var unionSet = valueqq.union(valueName).sorted()

print(unionSet)


valueqq = [1,2,3,4,5]

valueName  = [4,5,6]

//在一个集合,但不在另一个集合,创建一个新的集合

var subtractingSet = valueqq.subtracting(valueName).sorted()

print(subtractingSet)


valueqq = [4,5]

valueName  = [4,5,6]

//13、集合的关系和相等:

//(1)、相等

var isEquel = valueqq == valueName

print(isEquel)

//2)、集合是否包含:一个集合中的值是否被包含在另一个集合中

var isContain = valueqq.isSubset(of: valueName)

print(isContain)

//(3)、一个集合是否是另一个集合的子集

var isSubSet = valueqq.isStrictSubset(of: valueName)

print(isSubSet)

//4)、一个集合是否是另一个集合的父集

var isSuperSet = valueName.isStrictSuperset(of: valueqq)

print(isSuperSet)

//5)、判断两个集合是否不含有相同的值

var isJointSet = valueqq.isDisjoint(with: valueName)

print(isJointSet)


//字典:

var namesOfIntegers = [Int: String]()

namesOfIntegers = [:]

namesOfIntegers = [1:"sdfs",2:"sdsfsdf"]


var dic :[String:String] = [:]

let a:[String : String] = ["name":"sdfsdf"]


var b = [1:"sdfds",3:"sdfsdfsd"]

2014-12-16 14:26:26 weasleyqi 阅读数 13100

顾名思义,当我们查字典的时候,我们会根据索引去查找我们需要查找的资源,在swift中也是如此,字典的每一个对象都包含一个key和一个value,我们通过key去查找当前这个key所对应的value,与数组不同的是字典中的数据项在字典中没有具体的存储顺序。

和Swift中数组类似的,在Swift可变字典与不可变字典仅仅通过let和var的定义来区分,而在OC中是通过NSDictionary和NSMutableDictionary来区分的。

Swift的字典定义为:(key: value),对于key和value是有限制的,key的唯一限制是可hash的,这样就能保证key是独一无二的,key的address就为:addr = hash(key) , value = hashTavle[addr],先获取到key的地址,然后在哈希表中通过找到的key的地址来找到value的值。


字典的构造:
与数组类似的,字典也有很多相似的语法:
var dict = ["key1":"value1" , "key2":"value2"]
println(dict)

输出为:[key1: value1, key2: value2]
我们知道swift具有类型推导的功能,我们不用定义key和value的类型,OS就能帮我们推导出key和value都是String类型。

我们也可以在申明一个字典的时候定义好字典中key和value的类型。
var dict2 : Dictionary<String, Int> = ["key1":1, "key2":2]
println(dict2)

输出为:[key1: 1, key2: 2]

当然我们也有一种省略一点的定义方式:
var dict3 : [String : Int] = ["key3": 3, "key4":4]
println(dict3)

输出为:[key4: 4, key3: 3]

我们也可以像数组一样使用构造语句来创建一个空字典:
var emptyDict = Dictionary<String, String>()

此时我们就创建了一个key和value都是字符串的空字典;
如果我们在创建字典的时候不知道要放什么类型的数据,我们也可以利用swift的类型推导功能在以后添加数据项的时候自动推导:
var emptyDict2 = [ : ]


数组的操作:
对数据的基础操作包含增删改查,对字典的操作同样如此:
对字典新增一项时,我们可以通过下标来添加新的数据项,比如对dict添加一项:
dict["key3"] = "value3"
println(dict)

此时dict中有三项了,输出为:[key1: value1, key3: value3, key2: value2]

修改字典中某一项的值时也可以用下标来进行操作:
dict["key1"] = "NOValue"
println(dict)

此时的输出就为:[key1: NOValue, key3: value3, key2: value2]
swift还提供了一个updateValue的方法来更新字典中的值,
dict.updateValue("123", forKey: "key4")
println(dict)

如果key存在则更新key所对应的value,如果key不存在则新增一条记录。

和数组一样,我们可以通过字典的只读熟悉count来获取字典中的数据项的数量。

如果我们需要从一个字典中移除某个数据项,有这么2种方式:
1、用下标的方式来给某个键的对应值赋值为nil,这个该数据项就从字典中移除了:
dict["key4"] = nil
println(dict)

从输出中我们可以明显的看出key4所对应的数据项已经从字典中移除掉了;
2、用swift提供的函数:removeValueForKey:
dict.removeValueForKey("key1")
println(dict)

3、用removeAll方式来移除所有数据项。


字典遍历
还记得在数组的遍历中有2种方式,一种是for-in循环来遍历,一种是enumerate来遍历数据项和索引返回一个元祖,在字典的遍历中有下面几种方式:
1、for-in循环:
var dict = ["key1" : "value1" , "key2" : "value2" , "key3" : "value3"]

for key in dict{
    println(key)
}

for (key,value) in dict{
    println("key is \(key) and value is \(value)")
}

for (key, _) in dict {
    println(key)
}

for (_, value) in dict {
    println(value)
}


输出为:

(key1, value1)
(key3, value3)
(key2, value2)
key is key1 and value is value1
key is key3 and value is value3
key is key2 and value is value2
key1
key3
key2
value1
value3
value2


我们看到这几种方式,第一种直接打印出键值对的值,第二种我们的条件里面写了一个元组,分别打印key和value,第三种我们加了一个下划线,表示我们不关心第二项value的值,我们只要第一项,第四种方式即我们只关心value的值:


2、我们可以通过字典的keys熟悉来返回当前字典的所有的key,同样可以返回字典的所有value,
for keys in dict.keys {
    println(keys)
}

for values in dict.values {
    println(values)
}

字典的keys和values返回的是一个集合,我们可以直接使用keys或者values属性来构造一个新数组:
let keysArray = Array(dict.keys)
println(keysArray)

字典中的数据项是无序排列的,当我们遍历字典的时候,key和value会重新排列,而且其中的顺序是不固定的。



欢迎大家指导,共同学习。





2016-05-24 17:26:47 jiang314 阅读数 3910

持续更新中~~

转载注明 http://blog.csdn.net/jiang314

前言

Swift语言提供Array、Set和Dictionary三种基本的集合类型用来存储集合数据。数组是有序的数据集;集合是无序无重复的数据集;而字典是无序的键值对数组集。

image

Swift的Array、Set和Dictionary类型被实现为泛型集合。因此,它所存储的元素的类型必须是一致的,同样,我们取出来的数据类型也是明确的。

集合的可变性

如果创建一个Arrays、Sets或Dictionaries并且把它分配成一个变量,这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项,或者改变集合中的数据项。

如果我们把Arrays、Sets或Dictionaries分配成常量,那么它就是不可变的,它的大小和内容都不能被改变。

若我们确定集合不需要改变,那么我们应该使用不可变集合,也就是使用let声明,那样编译器会为我们优化。

// 在swift中要让Array、Set、Dictionary类型的变量是可变的,用var声明就可以了。
// 如果不希望可变,用let声明即可。
let immutableArrray = [Int]()

// 提示:error: immutable value of type '[Int]' only has mutating
// members named 'append'
//immutableArrray.append(12)

// OK
var mutableArray = [Int]()
mutableArray.append(12)

我的博客:http://blog.csdn.net/jiang314


数组

数组使用有序列表存储同一类型的多个值,相同的值可以多次出现在一个数组的不同位置中。我们需要明确,数组是有序的,元素类型是相同的。

Swift中的Array与Foundation中的NSArray是桥接的,可以相互转换。

1、创建一个空数组

由于Swift中的数组是泛型,因此必须指定元素的数据类型:

//1、创建空数组
    
    //定义数组只能保存字符串
    var array:[String]
    //定义数组只能保存int
    var arrint = [Int]()
    //定义数组,使用结构体Array的构造写法
    var anotherEmptyArray = Array<Int>()


2、创建带默认值的数组

Swift提供了如下方法,可以创建带有默认值的数组,这个构造方法是使用count个指定元素来初始化:

//2、创建带默认值得数组
    // threeDoubles 是一种 [Double] 数组,等价于 [1.0, 1.0, 1.0]
    var threeDoubles = [Double](count: 3, repeatedValue:1.0)

3、数组相加来创建数组

两个数组能够通过加号+来创建一个合并的数组,是因为苹果为我们提供了这样的方法:

//3、数组相加 来创建数组
    //要求:遵守RRC协议 ; 两个集合的元素类型要求相同
    //数组是遵守RRC协议的.
    // anotherThreeDoubles 被推断为 [Double],等价于 [2.5, 2.5, 2.5]
    var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
    // sixDoubles 被推断为 [Double],等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
    var sixDoubles = threeDoubles + anotherThreeDoubles

4、实例构造数组

我们可以使用字面量数组来进行数组构造,这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值:

//4、创建实例数组
    // shoppingList 已经被构造并且拥有两个初始项。
    var shoppingList: [String] = ["Eggs", "Milk"]
    // 由于类型是明确的,因此我们可以交由编译器来推断类型数组的类型:
    var shoppingListt = ["Eggs", "Milk"]


5、访问和修改数组

常见的数组访问和修改操作有:

  • 获取数组元素个数
  • 判断数组是否为空
  • 数组追加元素
  • 数组在某个位置插入元素
  • 数组在某个范围插入元素

5.1 数组元素个数

获取数组元素的个数,可通过count属性获取:

print("The shopping list contains \(shoppingList.count) items.")

5.2 数组判断是否为空

判断数组是否为空,可以通过isEmpty属性判断,也可以通过count判断:

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}

// 或者通过count属性
if shoppingList.count == 0 {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}

5.3 数组末尾追加元素

常用的有以下几种方法:

  • 通过append()追加
  • 通过appendContentsOf()追加
  • 通过+=追加

//末尾追加:通过append()追加;通过appendContentsOf()追加;通过+=追加
    var array21 = [1, 2]
    // 追加单个元素
    array21.append(3)
    // 追加一个数组
    array21 += [4, 5]
    // 追加一个集合
    array21.appendContentsOf([6, 7])
    // 追加一个序列:1,2,3,4,5,6.  要求数组为INT类型
    array21.appendContentsOf(1...6)

5.4 数组插入元素

数组提供了insert(_:at:)方法插入数据:

array21.insert(121, atIndex: 2)

5.5 数组修改值

我们也可以通过下标获取或者修改数据,我们先看看声明:

//数组修改值:
    // 下标
    array21[0] = 100; print(array21[0])
    // 可以修改指定范围的值
    array21[1..<4] = [77, 88, 99]; print(array21[1..<4])
    // replaceRange(_:with:)来替换值:
    array21.replaceRange(1...2, with: [10, 12])

5.6 数组移除元素

先看看苹果所提供的方法:

// 删除第一个
    let element = array.removeAtIndex(0)
    // 删除最后一个
    let lastElement = array.removeLast()
    // 删除所有元素,但是内存不释放,空间容量保留
    array.removeAll(keepCapacity: true)
    // 删除所有元素,且不保留原来的空间
    array.removeAll(keepCapacity: false)
    // 移除位置1、2、3的元素
    array.removeRange(1...3)
    // 移除第一个元素
    let first = array.removeFirst()
    // 移除前三个元素
    array.removeFirst(3)


5.7 数组遍历

常用的数组遍历有几种。

// 第一种,只获取元素值 :
    for item in array {
        print(item)
    }
    // 第二种,获取元素值及索引:
    for (index, value) in array.enumerate() {
        print("index: \(index), value = \(value)")
    }

我的博客:http://blog.csdn.net/jiang314


集合

集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。

为了存储在集合中,该类型必须是可哈希化的。也就是说,该类型必须提供一个方法来计算它的哈希值。一个哈希值是Int类型的,它和其他的对象相同,其被用来比较相等与否,比如a==b,它遵循的是a.hashValue == b.hashValue。Swift 的所有基本类型(比如String,Int,Double和Bool)默认都是可哈希化的,它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在枚举有讲述)默认也是可哈希化的。

使用自定义的类型作为集合的值或者是字典的键值类型时,需要使自定义类型服从Swift标准库中的Hashable协议。服从Hashable协议的类型需要提供一个类型为Int的取值访问器属性hashValue。这个由类型的hashValue返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。 因为hashable协议服从于Equatable协议,所以遵循该协议的类型也必须提供一个”是否等”运算符(\==)的实现。这个Equatable协议需要任何遵循的\==的实现都是一种相等的关系。也就是说,对于a,b,c三个值来说,\==的实现必须满足下面三种情况:

  • a\==a(自反性)
  • a\==b 可推出 b\==a(对称性)
  • a\==b&&b\==c 可推出 a\==c(传递性)

1、空集合

Swift中的Set类型被写为Set<Element>,这里的Element表示Set中允许存储的类型,和数组不同的是,集合没有等价的简化形式。

//1 空集合
    var emptySet = Set<Int>()
    print(emptySet.count) // 0
    // 当变量已经有明确的类型时,再用空数组来初始化[],其类型也是可推断的
    emptySet = []// 类型为Set<Int>()

2、初始化集合(Initializing An Empty Set)

可以直接使用数组字面量来初始化集合:

// 2、初始化集合
    var favSet:Set<String> = ["mi","wer"]
    var fwas:Set  = ["we","sdsv"]
    var asss:Set<String> = ["as","sd","as","sd"]//重复的as,sd会自动删除

3、访问集合(Accessing A Set)

获取集合元素的个数,可以通过count只读属性获取,其时间复杂度为O(1),也就是常量,因此效率是极高的。想想时间复杂度能达到O(1),说明内部并不是列表,而是类似字典那样的哈希表,不过具体内部是如何,这里不细说,还得去查看源代码才能知晓。

//3 访问集合
    //获取个数   可以通过count只读属性获取,其时间复杂度为O(1),也就是常量,因此效率是极高的
    //public var count: Int { get }
    let count = asss.count
    // 判断是否为空集:isEmpty属性判断是否为空:
    if favSet.isEmpty {
        print("empty set")
    } else {
        print("non empty set")
    }
    // 判断是否包含元素
    if favSet.contains("wahaha") {
        print("fav set contains wahaha")
    } else {
        print("fav set doesn\'t not contain wahaha")

    }

4、遍历集合(Iterating Over A Set)

遍历很少能离开得了for-in语法

//4.1遍历一个set。使用for-in

    for value in favSet {
        print(value)// 这是无序的
    }
    // 4.2遍历集合,同时使之有序
    // sort方法
    for value in favSet.sort({ (e, ee) -> Bool in
        return e > ee // 由我们指定排序类型desc(降序)
    }) {
        print(value)// mikl egg
    }
    // 4.3或者直接使用sort无参数(默认为asc升序)
    for value in favSet.sort() {
        print(value)// egg   milk
    }
    // 4.4当然还可以使用最原始的方法来遍历:
    for var i = favSet.startIndex; i != favSet.endIndex; i = i.successor() {
        print("for-i-in" + favSet[i])
    }

5、集合基本操作(Fundamental Set Operations)

集合的基本操作有:

  • 求交集:使用intersect(_:)方法根据两个集合中都包含的值创建的一个新的集合。
  • 求非交集:使用exclusiveOr(_:)方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
  • 求并集:使用union(_:)方法根据两个集合的值创建一个新的集合。
  • 求差集:使用subtract(_:)方法根据不在该集合中的值创建一个新的集合。

image

/** 5、集合基本操作
     求交集:使用 a intersect(b) 方法根据两个集合中都包含的值创建的一个新的集合 (ab的交集)。
     求非交集:使用 a exclusiveOr(b)方法根据在一个集合中但不在两个集合中的值创建一个新的集合(ab并集减去交集的集合)。
     求并集:使用 a union(b)方法根据两个集合的值创建一个新的集合 (ab并集)。
     求差集:使用 a subtract(b)方法根据不在该集合中的值创建一个新的集合(a中非b的集合)。
     */
    let set11: Set = [1, 2, 3, 4, 5]
    let set21: Set = [1, 3, 4, 8]
    
    // 求两个集合的交集
    // 1, 3, 4
    print(set11.intersect(set21))
    
    // 求两个集合的并集
    // 1, 2, 3, 4, 5,8
    print(set11.union(set21).sort())
    
    // 求集合set1去掉set1与set2的交集部分
    // 2, 5
    print(set11.subtract(set21).sort())
    
    // 求集合set1与set2的并集 去掉 集合set1与set2的交集 部分
    // 2, 5, 8
    print(set11.exclusiveOr(set21).sort())

6、集合成员关系(Relationships Of Set members)

  • 使用\==来判断两个集合是否包含全部相同的值。
  • 使用isSubsetOf(_:)方法来判断是否为子集
  • 使用isSupersetOf(_:)方法来判断是否为超集
  • 使用isStrictSubsetOf(_:)或者isStrictSupersetOf(_:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。
  • 使用isDisjointWith(_:)方法来判断两个集合是否不含有相同的值。

image

从图中可以看出:

  1. 集合a全部包含b,也就是说b是a的子集
  2. 集合a与集合b相交,但是a与b不完全包含
  3. 集合c与集合b完全没有交集

let set1: Set = [1, 2, 3, 4, 5]
    let set2: Set = [1, 3, 4, 8]
    // set1并没有全部被set2包含
    print(set1.isSubsetOf(set2))// false
    
    let set3: Set = [1, 2, 5]
    // set3全部在set1中
    print(set3.isSubsetOf(set1))// true
    
    // set1真包含set3,因此set1是set3的超集
    print(set1.isSupersetOf(set3))// true
    
    // set1是set3的严格超集,因为Set1真包含set3且set1 != set3
    print(set1.isStrictSupersetOf(set3))// true
    
    // set1真包含set3,且set1 != set3,因此set3是set1严格的真子集
    print(set3.isStrictSubsetOf(set1))// true
    
    let set4: Set = [1, 5, 2]
    // 因为set3和set4的元素是一样的,即相等
    print(set4.isStrictSubsetOf(set3))// false
    
    // 这两个集合中有相同的元素
    print(set3.isDisjointWith(set4))// false
    
    let set5:Set = [9, 6]
    // set5和set4没有相同的元素
    print(set5.isDisjointWith(set4))// true

我的博客:http://blog.csdn.net/jiang314

字典

字典是一种存储多个相同类型的值的容器。每个值都关联唯一的键,键作为字典中的这个值数据的标识符。和数组中的数据项不同,字典中的数据项并没有顺序的。我们在需要通过key访问数据的时候使用字典,这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

Swift中的Dictionary与Foundation中的NSDictionary是桥接的,可以互相转换使用。

它是基于哈希表从key到value实例的映射,它的键值是无序的。要求key是遵守Hashable的。
其正规语法应该是:Dictonary<key, value>

1、创建空字典

// 1、创建空字典
    var emptyDict = [Int: String]()
    // 或者
    emptyDict = Dictionary<Int, String>()
    // 当创建过emptyDict后,再用[:]又成为一个空字典
    emptyDict = [:]

2、初始化字典

//2、初始化字典(Initializing A Dictionary)
    
    // 多个键值对用逗号分割
    // 通过类型推断是可以推断出来类型为[String: String]
    var dict = ["A": "Apple", "B": "Bubble"]
    // 手动指明数据类型
    var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
    
    //声明不可变字典:
    // 如果不希望字典可变,用let声明即可
    let immutableDict = ["A": "Apple", "B": "Bubble"]
    // 无法调用,因为是不可变的
    //immutableDict.updateValue("App", forKey: "A")
    //immutableDict += ["AB:", "Apple Bubble"]

3、访问和修改字典

我们可以通过字典的方法和属性来访问和修改字典,或者通过使用下标语法。

// 3、访问和修改字典
    
    // 我们可以通过字典的方法和属性来访问和修改字典,或者通过使用下标语法。
    // 3.1 判断是否为空字典:
    
    if dict.isEmpty {
        print("dict is an empty dictionary")
    } else {
        print("dict is not an empty dictionary")
    }
    // 或者通过获取字典元素的个数是否为0
    if dict.count == 0 {
        print("dict is an empty dictionary")
    } else {
        print("dict is not an empty dictionary")
    }
    
    // 3.2 可以直接通过下标获取元素:
    // 通过key直接获取
    var apple = dict["A"]
    
    // 获取索引获取(key, value),再获取值
    // 由于字典中的(key, value)是元组,因此可以直接通过点语法获取
    let startKeyValue = dict[dict.startIndex]//第一个键值对
    let value = startKeyValue.1//值
    
    // 3.3 读取时,判断是否有值
    if let value = dict["BB"] {
        print("value is \(value)")
    } else {// 输入这行
        print("The key BB doesn\'t not exist in dict")
    }
    
    // 3.4 可以直接通过下标来修改或者增加值:
    // 修改,如果不存在,则会增加,否则更新值
    dict["A"] = "Good Apple"
    
    // 或者用API,如果不存在,则会增加,否则只是更新值
    if let oldValue = dict.updateValue("Dog", forKey: "D") {
        print("The old value is \(oldValue)")
    } else {
        // 输出这行
        print("The key D does\'t not exist before update")
    }
    
    // 3.5 移除元素:
    // 通过下标语法移除元素
    dict["D"] = nil
    // 或者通过调用removeValueForKey方法来移除
    if let removedValue = dict.removeValueForKey("D") {
        print("The removed value is \(removedValue)")
    } else {
        print("The key D doesn'\t exist in dict, can\' be removed.")
    }
    // 或者清空字典:
    dict.removeAll()

4、字典遍历

// 4 字典遍历(Iterate Over A Dictionary)
    // 字典中每个元素是一个键值对,而这个键值对其实就是一个元组:
    // 用for-in遍历,形式为(key, value)
    for (key, value) in dict {
        print("\(key): \(value)")
    }
    // 可以通过遍历所有的key:
    for key in dict.keys {
        print("\(key): \(dict[key])")
    }
    // 也可以遍历所有的值:
    for value in dict.values {
        print("\(value)")
    }


5、字典值或者键转换成数组

将字典的key或者value转成数组:

    // 获取所有的值
    let values = [String](dict.values)
    
    // 获取所有的键
    let keys = [String](dict.keys)

我的博客:http://blog.csdn.net/jiang314


最后:

本篇博文是笔者在学习Swift 2.1的过程中记录下来的,同时参考了标哥的博客,在此一并感谢。


分享一些swift学习的资料,和大家一块学习,有啥问题还请留言哦~~



2016-08-04 14:53:44 CodingFire 阅读数 4061

我们知道字典是无序的,要想排序可以根据key来进行,然后再根据key的索引找出对应的value,下面有个简单的例子:

      //既然是排序,首先要保证key一定要是同一种类型,不要使用多种类型,如果有多种类型,就需要先挑出来归为一类,然后对剩下的进行排序
        var dic = Dictionary<String,AnyObject>()

        dic["a"] = "item-a"
        dic["c"] = "item-c"
        dic["b"] = "item-b"
        dic["d"] = "item-d"


        var array1 =  dic.keys.sort(>)

        for item in array1 {
            print("\(item)" + ":" + (dic["\(item)"]! as! String));
        }
2016-11-25 18:13:28 dylan_lwb_ 阅读数 18312
// Playground - noun: a place where people can play

import UIKit

//------------------------------------------------------------------------------
// 1. for
// 传统的for循环方式在swift中同样支持
var num = 0
for(var i = 0; i < 10 ; i++) {
    num += i
}
num

//------------------------------------------------------------------------------
// 2. for-in用来遍历一个区间(range)、序列(sequence)、集合(collection)、系列(progression)
//    所有的元素执行一系列语句

// 1> 闭区间循环,从1循环到10
num = 0
for i in 1...10 {
    num += i
}
num

// 2> 开区间循环,从1循环到9
num = 0
for i in 1..<10 {
    num += i
}
num

// 3> 如果不需要知道区间内每一项的值,可以使用下划线(_)替代变量名,忽略对区间数值的访问
num = 0
for _ in 1...10 {
    num++
}
num

num = 0
for i in 0...5 {
    for j in 0...5 {
        num = i + j
    }
}
num

//------------------------------------------------------------------------------
// 3. 循环生成数组
var array = [String]()
for i in 0..<10 {
    array.append("dylan \(i)")
}
array

//------------------------------------------------------------------------------
// 4. 循环遍历字典
var ageDict:Dictionary<String, Int> = ["mary": 19, "rose": 20]

var names = [String]()
var ages = [Int]()
for (key, value) in ageDict {
    names.append(key)
    ages.append(value)
}
names
ages

var keys = [String]()
var values = [String]()
var dict1 = ["name": "mike", "age": "18"];
for (name, age) in dict1 {
    keys.append(name)
    values.append(age)
}
keys
values

//------------------------------------------------------------------------------
// 5. 使用标签退出循环
// 使用标签的其中1个作用是:可以明确指定要退出哪个循环,以下示例是退出名字为"mainloop"的循环
var result = 1;
mainloop : for i in 1...5 {
    for j in 1...5 {
        result += j
        
        if (i == 3 && j == 3) {
            break mainloop
        }
    }
}
result