Collection Types Of Swift

  // 在swift中要让Array、Set、Dictionary类型的变量是可变的，用var声明就可以了。 // 如果不希望可变，用let声明即可。 letimmutableArrray = [Int]()   // 提示：error: immutable value of type '[Int]' only has mutating // members named 'append' //immutableArrray.append(12)   // OK varmutableArray = [Int]() mutableArray.append(12)   

  // 使用构造语法来创建一个由特定数据类型构成的空数组： // 方括号中必须指定类型，因为Array是一种泛型 varemptyArray = [Int]()   // 也可以使用结构体Array的构造写法 varanotherEmptyArray = Array<Int>()   // 如果之前类型明确了，直接再用[]即可.一样是Int类型的元素，是可推断出来的 emptyArray = []   

  /// Construct a Array of `count` elements, each initialized to /// `repeatedValue`. publicinit(count: Int, repeatedValue: Element)   

  varthreeDoubles = [Double](count: 3, repeatedValue:0.0) // threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]   

  publicfunc +<RRC1 : RangeReplaceableCollectionType, RRC2 : RangeReplaceableCollectionType whereRRC1.Generator.Element == RRC2.Generator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1   

  // anotherThreeDoubles 被推断为 [Double]，等价于 [2.5, 2.5, 2.5] varanotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)   // sixDoubles 被推断为 [Double]，等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5] varsixDoubles = threeDoubles + anotherThreeDoubles   

  // shoppingList 已经被构造并且拥有两个初始项。 var shoppingList: [String] = ["Eggs", "Milk"]   

  varshoppingList = ["Eggs", "Milk"]   

  // 打印结果："The shopping list contains 2 items." print("The shopping list contains /(shoppingList.count) items.")   

  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.") }   

  /// Append the elements of `newElements` to `self`. /// /// - Complexity: O(*length of result*). publicmutatingfuncappendContentsOf<S : SequenceType where S.Generator.Element == Element>(newElements: S) /// Append the elements of `newElements` to `self`. /// /// - Complexity: O(*length of result*). publicmutatingfuncappendContentsOf<C : CollectionType where C.Generator.Element == Element>(newElements: C)   

  vararray = [1, 2]   // 追加单个元素 array.append(3)   // 追加一个数组 array += [4, 5]   // 追加一个集合 array.appendContentsOf([6, 7])   // 追加一个序列：1,2,3,4,5,6 array.appendContentsOf(1...6)   

  /// Insert `newElement` at index `i`. /// /// - Requires: `i <= count`. /// /// - Complexity: O(`count`). publicmutatingfuncinsert(newElement: Element, atIndex i: Int)   

  vararray = [1, 2] array.insert(55, atIndex: 2)   

  // 这个方法是在index位置插入数据或者获取index位置的数据 publicsubscript (index: Int) -> Element   // 这个方法是在指定的range插入多个数据或者获取指定range的数据 publicsubscript (subRange: Range<Int>) -> ArraySlice<Element>   

  // 修改元素值，可以通过索引 array[0] = 100 // 获取 print(array[0])   // 可以修改指定范围的值 array[1..<4] = [77, 88, 99] // 获取 print(array[1..<4])   

  array.replaceRange(1...2, with: [10, 12])   

  // 移除最后一个元素 publicmutatingfuncremoveLast() -> Element   // 某个指定位置的元素 publicmutatingfuncremoveAtIndex(index: Int) -> Element   // 移除某个范围 publicmutatingfuncremoveRange(subRange: Range<Self.Index>)   // 移除前n个 publicmutatingfuncremoveFirst(n: Int)   // 移除第一个 publicmutatingfuncremoveFirst() -> Self.Generator.Element   // 清空 publicmutatingfuncremoveAll(keepCapacity keepCapacity: Bool = default)   

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

  foritemin array {     print(item) }   

  for (index, value) in array.enumerate() {   print("index: /(index), value = /(value)") }   

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

  // 用数组构造集合 var favSet: Set<String> = ["milk", "egg"]   // 如果元素都是相同类型，带有初始化，可以省略类型 var favSet1: Set = ["good milk", "bad egg"]   

  // 重复的数据会被自动去重 var favSet: Set<String> = ["milk", "egg", "egg", "milk"] print(favSet.count)// 2   

  /// The number of members in the set. /// /// - Complexity: O(1). publicvarcount: Int { get }   

  letcount = favSet.count   

  // 官方声明如下： /// `true` if the set is empty. publicvarisEmpty: Bool { get }      // 判断是否为空集 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") }   

  // 遍历一个set。使用for-in forvaluein favSet {   print(value)// 这是无序的 }   

  // 要使之有序 // sort方法 forvaluein favSet.sort({ (e, ee) -> Bool in   return e > ee // 由我们指定排序类型desc（降序） }) {   // milk   // egg   print(value) }   // 或者： // 或者直接使用sort无参数（默认为asc升序） forvaluein favSet.sort() {   // egg   // milk   print(value) }   

  forvar i = favSet.startIndex; i != favSet.endIndex; i = i.successor() {   print("for-i-in" + favSet[i]) }   

  let set1: Set = [1, 2, 3, 4, 5] let set2: Set = [1, 4, 3, 8]   // 求两个集合的交集 // 3, 1, 4 print(set1.intersect(set2))   // 求两个集合的并集 // 1, 2, 3, 4, 5 print(set1.union(set2).sort())   // 求集合set1去掉set1与set2的交集部分 // 2, 5 print(set1.subtract(set2).sort())   // 求集合set1与set2的并集 去掉 集合set1与set2的交集 部分 // 2, 5, 8 print(set1.exclusiveOr(set2).sort())   

  let set1: Set = [1, 2, 3, 4, 5] let set2: Set = [1, 4, 3, 8]   // false // set1并没有全部被set2包含 print(set1.isSubsetOf(set2))   let set3: Set = [1, 2, 5]   // true // 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))   let set4: Set = [1, 5, 2]   // false // 因为set3和set4的元素是一样的，即相等 print(set4.isStrictSubsetOf(set3))   // false // 这两个集合中有相同的元素 print(set3.isDisjointWith(set4))   let set5:Set = [9, 6]   // true // set5和set4没有相同的元素 print(set5.isDisjointWith(set4))   

  /// A hash-based mapping from `Key` to `Value` instances.  Also a /// collection of key-value pairs with no defined ordering. publicstruct Dictionary<Key : Hashable, Value> : CollectionType, DictionaryLiteralConvertible   

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

  // 多个键值对用逗号分割 // 通过类型推断是可以推断出来类型为[String: String] vardict = ["A": "Apple", "B": "Bubble"]   // 手动指明数据类型 var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]   

  // 如果不希望字典可变，用let声明即可 letimmutableDict = ["A": "Apple", "B": "Bubble"] // 无法调用，因为是不可变的 //immutableDict.updateValue("App", forKey: "A") //immutableDict += ["AB:", "Apple Bubble"]   

  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") }   

  // 通过key直接获取 varapple = dict["A"]   // 获取索引获取(key, value)，再获取值 // 由于字典中的(key, value)是元组，因此可以直接通过点语法获取 letstartKeyValue = dict[dict.startIndex] let value = startKeyValue.1   // 读取时，判断是否有值 if letvalue = dict["BB"] {   print("value is /(value)") } else {   // 输入这行   print("The key BB doesn/'t not exist in dict") }   

  // 修改，如果不存在，则会增加，否则更新值 dict["A"] = "Good Apple"   // 或者用API，如果不存在，则会增加，否则只是更新值 if letoldValue = dict.updateValue("Dog",forKey: "D") {   print("The old value is /(oldValue)") } else {   // 输出这行   print("The key D does/'t not exist before update") }   

  // 通过下标语法移除元素 dict["D"] = nil   // 或者通过调用removeValueForKey方法来移除 if letremovedValue = dict.removeValueForKey("D") {   print("The removed value is /(removedValue)") } else {   print("The key D doesn'/t exist in dict, can/' be removed.") }   // 或者清空字典： dict.removeAll()   

  // 用for-in遍历，形式为(key, value) for (key, value) in dict {   print("/(key): /(value)") }   

  // 可以遍历key forkeyin dict.keys {   print("/(key): /(dict[key])") }   

  forvaluein dict.values {   print("/(value)") }   

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

文章并非纯翻译，而是练习语法而记录下来的内容