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)