iOS - Swift Set 集合

前言

• Set：集合

      public struct Set<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConvertible
      public class NSSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration

  • 集 NSSet 是一个无序对象的集合。集也有动态和静态之分，NSSet 是静态类型，成员不能被修改。NSMutableSet 是动态类型，成员可以被修改。

  • 集和数组不一样的是，它存储的每一个元素都是唯一的，没有完全相同的两个元素。所以数组中如果有两个相同的值，转换为集后只会有一个值。

• NSCountedSet：计数集合

      public class NSCountedSet : NSMutableSet

  • NSCountedSet 这种集合中同一对象可以出现多次，然而并非在集合中存放多次这个对象，而是维护一个次数计数。当第一次将对象添加到集合中时，对象的 count 值被置为 1，然后每次将这个对象添加到集合中，count 值就会增加 1，每次从集合中删除对象，count 值就会减 1.当对象的 count 值为零时，实际上对象本身就被删除了。

• NSIndexSet：索引集合

      public class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding
      public class NSMutableIndexSet : NSIndexSet

  • NSIndexSet 这种集合用于存储有序的索引到某种数据结构，比如数组。

1、集合的 创建

    // Set 型集合
            
        // 不赋初值，指定数据类型为 String 型
        let set1 = Set<String>()
            
        // 不指定数据类型，自动推断
        let set2:Set = [1, 3, 5, 7]
            
        // 指定数据类型为 Int 型
        let set3:Set<Int> = [1, 3, 5, 7]
            
    // NSSet 型集合
            
        let swiftArr:Array = ["a", "b", "c"]
        let swiftSet:Set = [1, 2, 3, 4]
            
        // 创建一个空集合
        let nsSet1:NSSet = NSSet()
            
        // 指定多个元素值
        let nsSet2:NSSet = [2, 4, 6, 8]
            
        // 由 Array 型数组创建
        let nsSet3:NSSet = NSSet(array:swiftArr)
            
        // 由 Set 型集合创建
        let nsSet4:NSSet = NSSet(set: swiftSet)
            
        // 由 NSSet 型集合创建
        let nsSet5:NSSet = NSSet(set: nsSet3)
            
        // 指定一个元素值
        let nsSet6:NSSet = NSSet(object: 7)
            
        // 指定多个元素值
        let nsSet7:NSSet = NSSet(objects: 2, 4, 6, 8)

2、集合成员 个数的计算

    // Set 或 NSSet 型集合
        
        let set:NSSet = [1, 3, 5, 7]
        
        let num:Int = set.count

3、集合元素的获取

    // NSSet 型集合
            
        let nsSet:NSSet = [2, 4, 6, 8]
            
        // 获取集合中指定的元素，不存在时返回 nil
        let object1:AnyObject? = nsSet.member(8)
            
        // 获取集合中随机的一个值，集合为空时返回 nil
        let objects1:AnyObject? = nsSet.anyObject()
            
        // 获取集合中所有的元素
        let objects2:AnyObject = nsSet.allObjects

4、集合的比较

    // Set 型集合
            
        let swiftSet1:Set = [1, 3, 5, 7]
        let swiftSet2:Set = [5, 7, 9, 11]
            
        // 判断集合是否为空
        let bl1:Bool = swiftSet1.isEmpty
            
        // 判断集合中是否包含某个元素
        let bl2:Bool = swiftSet1.contains(7)
            
        // 相等，判断两个集合是否相等
        let bl3:Bool = swiftSet1 == swiftSet2
            
        // 子集，判断当前集合是否是指定集合的子集
        let bl4:Bool = swiftSet1.isSubsetOf(swiftSet2)
            
        // 交集，返回当前集合与指定集合的交集，没有交集时返回一个空集合
        let interSet:Set = swiftSet1.intersect(swiftSet2)
            
        // 并集，返回当前集合与指定集合的并集
        let unionSet:Set = swiftSet1.union(swiftSet2)
            
    // NSSet 型集合
            
        let nsSet1:NSSet = [2, 4, 6, 8]
        let nsSet2:NSSet = [6, 8, 10, 12]
        let nsSet3:NSMutableSet = [6, 8, 10, 12]
            
        // 判断集合中是否包含某个元素
        let bl5:Bool = nsSet1.containsObject(8)
            
        // 相等，判断两个集合是否相等
        let bl6:Bool = nsSet1 == nsSet2
                
        // 相等，判断两个集合是否相等
        let bl7:Bool = nsSet1.isEqualToSet(nsSet2 as Set)
            
        // 子集，判断当前集合是否是指定集合的子集
        let bl8:Bool = nsSet1.isSubsetOfSet(nsSet2 as Set)
            
        // 交集，判断当前集合与指定集合是否有交集
        let bl9:Bool = nsSet1.intersectsSet(nsSet2 as Set)
            
        // 交集，返回当前集合与指定集合的交集，返回到当前集合中
        nsSet3.intersectSet(nsSet1 as Set)
            
        // 并集，返回当前集合与指定集合的并集，返回到当前集合中
        nsSet3.unionSet(nsSet1 as Set)
            
        // 补集，返回当前集合与指定集合的补集，返回到当前集合中，当前集合中删除与指定集合的交集
        nsSet3.minusSet(nsSet1 as Set)

5、集合元素的添加

    // Set 型集合
            
        var swiftSet:Set = [1, 3, 5, 7]
            
        // 向集合中添加一个元素
        swiftSet.insert(8)                                                  
            
    // NSSet 型集合
            
        let nsSet:NSMutableSet = [2, 4, 6, 8]
            
        // 向集合中添加一个元素
        nsSet.addObject(10)                                                 
            
        // 向集合中添加一个数组
        nsSet.addObjectsFromArray([11, 12, 12])                             

6、集合元素的删除

    // Set 型集合
            
        var swiftSet:Set = [1, 3, 5, 7]
            
        // 删除第一个元素
        swiftSet.removeFirst()                                              
            
        // 删除指定元素
        swiftSet.remove(1)                                                  
            
        // 删除所有元素
        swiftSet.removeAll(keepCapacity: true)                             
            
    // NSSet 型集合
            
        let nsSet:NSMutableSet = [2, 4, 6, 8]
            
        // 删除指定元素
        nsSet.removeObject(4)                                               
            
        // 删除指定集合，当前集合中删除与指定集合的交集
        nsSet.minusSet([2, 6])                                              
            
        // 删除所有元素
        nsSet.removeAllObjects()                                            

7、集合元素的修改

    // NSSet 型集合
            
        let nsSet:NSMutableSet = [2, 4, 6, 8]
            
        nsSet.setSet([1, 2, 3])

8、集合的遍历

    // NSSet 型集合
            
        let nsSet:NSSet = [2, 4, 6, 8]
            
        // 用闭包遍历
            
            nsSet.enumerateObjectsUsingBlock { (obj:AnyObject, stop:UnsafeMutablePointer<ObjCBool>) in
                
                print(obj)
            }
                
        // 用迭代遍历
            
            let enu:NSEnumerator = nsSet.objectEnumerator()
                    
                // AnyObject 后不要加 ？，否则会导致一直循环
                while let obj:AnyObject = enu.nextObject() {
                    
                print(obj)
            }
                
        // 条件遍历
            
            let set:Set = nsSet.objectsPassingTest { (obj:AnyObject, stop:UnsafeMutablePointer<ObjCBool>) -> Bool in
                
                return (obj as! Int) > 5 ? true : false
            }
            
            print(set)

9、计数集合的创建

    let nsCountSet1:NSCountedSet = NSCountedSet()
    let nsCountSet2:NSCountedSet = NSCountedSet(capacity: 0)
        
    let nsCountSet3:NSCountedSet = NSCountedSet(array: [1, 3, 5, 7, 9])
        
    let nsCountSet4:NSCountedSet = NSCountedSet(set: [6, 9])
        
    let nsCountSet5:NSCountedSet = NSCountedSet(object: 8)
    let nsCountSet6:NSCountedSet = NSCountedSet(objects: [2, 3, 6, 8], count: 4)

10、计数集合元素的添加

    let nsCountSet:NSCountedSet = [1, 3, 5, 7, 9]
        
    // 向集合中多次添加同一个元素，该元素的计数值增加
    nsCountSet.addObject(6)

11、计数集合元素的删除

    let nsCountSet:NSCountedSet = [1, 3, 5, 7, 9]
        
    // 从集合中删除元素，该元素的计数值减小
    nsCountSet.removeObject(5)                                          

12、计数集合计数值的计算

    let nsCountedSet:NSCountedSet = NSCountedSet(array: [1, 2, 3])
        
    nsCountedSet.addObject(2)
    nsCountedSet.removeObject(1)
        
    // 检索集合中指定元素的计数值
    let num1:Int = nsCountedSet.countForObject(1)
        
    // 检索集合中指定元素的计数值
    let num2:Int = nsCountedSet.countForObject(2)

13、索引集合的创建

    let indexSet1:NSIndexSet = NSIndexSet()
        
    let indexSet2:NSIndexSet = NSIndexSet(index: 8)
        
    let indexSet3:NSIndexSet = NSIndexSet(indexSet: indexSet2)
        
    let indexSet4:NSIndexSet = NSIndexSet(indexesInRange: NSMakeRange(1, 8))

14、索引集合元素数量的计算

    let indexSet:NSIndexSet = NSIndexSet(indexesInRange: NSMakeRange(1, 8))
        
    // 计算索引集合所有索引的数量
    let num1:Int = indexSet.count
    
    // 计算索引集合中某一范围内的索引的数量
    let num2:Int = indexSet.countOfIndexesInRange(NSMakeRange(3, 4))

15、索引集合元素的获取

    let indexSet:NSIndexSet = NSIndexSet(indexesInRange: NSMakeRange(1, 8))
        
    // 获取索引集合中的第一个索引，如果集合为空则返回 NSNotFound
    let index1:Int = indexSet.firstIndex
    
    // 获取索引集合的最后一个索引，如果集合为空则返回 NSNotFound
    let index2:Int = indexSet.lastIndex
    
    // 获取索引集合中小于指定的索引且最接近的索引，如果没有小于的索引则返回 NSNotFound
    let index3:Int = indexSet.indexLessThanIndex(5)
    
    // 获取索引集合中小于等于指定的索引且最接近的索引，如果没有小于的索引则返回 NSNotFound
    let index4:Int = indexSet.indexLessThanOrEqualToIndex(5)
    
    // 获取索引集合中大于指定的索引且最接近的索引，如果没有大于的索引则返回 NSNotFound
    let index5:Int = indexSet.indexGreaterThanIndex(7)
    
    // 获取索引集合中大于等于指定的索引且最接近的索引，如果没有大于的索引则返回 NSNotFound
    let index6:Int = indexSet.indexGreaterThanOrEqualToIndex(7)

16、索引集合的判断

    let indexSet:NSIndexSet = NSIndexSet(indexesInRange: NSMakeRange(1, 8))
        
    // 判断索引集合中是否包含某个索引
    let bl1:Bool = indexSet.containsIndex(9)
    
    // 判断一个索引集合中是否包含另一个索引集合
    let bl2:Bool = indexSet.containsIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 3)))
    
    // 判断一个索引集合中是否包含某一个范围内的所有值
    let bl3:Bool = indexSet.containsIndexesInRange(NSMakeRange(2, 3))
    
    // 判断一个索引集合中是否包含某一个范围内的值（是否有交集）
    let bl4:Bool = indexSet.intersectsIndexesInRange(NSMakeRange(7, 3))
    
    // 判断两个索引集合是否相等
    let bl5:Bool = indexSet.isEqualToIndexSet(NSIndexSet(indexesInRange: NSMakeRange(1, 7)))

17、索引集合的添加

    let mIndexSet:NSMutableIndexSet = NSMutableIndexSet(indexesInRange: NSMakeRange(1, 3))
        
    // 添加一个索引元素，集合中已存在时会合并
    mIndexSet.addIndex(6)
    
    // 添加一个索引集合，两个索引集合有交集时会合并
    mIndexSet.addIndexes(NSIndexSet(indexesInRange: NSMakeRange(8, 2)))
    
    // 添加一个范围内的元素，有交集时会合并
    mIndexSet.addIndexesInRange(NSMakeRange(12, 3))

18、可变索引集合删除

    let mIndexSet:NSMutableIndexSet = NSMutableIndexSet(indexesInRange: NSMakeRange(1, 10))
        
    // 删除一个索引集合中的索引元素
    mIndexSet.removeIndex(2)
    
    // 删除指定集合中含有的索引元素
    mIndexSet.removeIndexes(NSIndexSet(indexesInRange: NSMakeRange(4, 2)))
    
    // 删除指定范围内含有的索引元素
    mIndexSet.removeIndexesInRange(NSMakeRange(8, 3))
    
    // 删除全部索引元素
    mIndexSet.removeAllIndexes()

19、索引集合的遍历

    let indexSet:NSIndexSet = NSIndexSet(indexesInRange: NSMakeRange(1, 5))
    
    // 用闭包遍历
    
        // 1. enumerateIndexesUsingBlock
    
            // 遍历获取索引集合的所有索引值
            indexSet.enumerateIndexesUsingBlock { (idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in             
         
                print(idx)
            }
        
        // 2. enumerateRangesUsingBlock
    
            // 遍历获取索引集合的起始值和索引元素数量
            indexSet.enumerateRangesUsingBlock { (range:NSRange, stop:UnsafeMutablePointer<ObjCBool>) in        
        
                print("\(range.location), \(range.length)")
            }
    
    // 条件遍历
    
        // 1. indexesPassingTest
    
            // 遍历索引集合，找出索引中所有满足条件的索引
            let indexs:NSIndexSet = indexSet.indexesPassingTest { (idx, stop) -> Bool in                        
                
                return idx > 3 ? true : false
            }
            
            indexs.enumerateIndexesUsingBlock { (idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in
   
                print(idx)
            }
        
        // 2. indexPassingTest
    
            // 遍历索引集合，找出索引中第一个满足条件的索引
            let index:Int = indexs.indexPassingTest { (idx, stop) -> Bool in                                    
                
                return idx > 3 ? true : false
            }
            
            print(index)