iOS

前言

	public struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer
	public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration

• 在 Swift 语言中，数据在被存储进某个数组之前，类型必须明确，且与数组其他元素类型相同。在 Swift 语言中的数组和 C 语言中的不同，Swift 语言中的数组是值类型的，不管是赋值还是当作参数传递，都只是维护他的拷贝。你可以放心的操作他的拷贝，因为你做的任何操作都不会反馈回它本身，这是值类型自身的规则。

1、Array 与 NSArray 的相互转换

• Array 与 NSArray 之间可以相互转换。Array 转成 NSArray 时，数组中的各项元素被转换为 AnyObject 类型。NSArray 转换成 Array 时，数组中的各项元素也被转换为 AnyObject 类型。

	// Array 转 NSArray
    
		// Array 转换成 NSArray<AnyObject> 型
		let nsArray1:NSArray = array
	
		// Array 转换成 NSArray<AnyObject> 型
		let nsArray2:NSArray = array as NSArray
	    
	// NSArray 转 Array
    
		// NSArray 转换成 Array<AnyObject> 型
		let swiftArray1:Array = nsArray1 as Array
	
		// NSArray 转换成 Array<AnyObject> 型
		let swiftArray2:Array = nsArray1 as [AnyObject]
	
		// NSArray 转换成 Array<Int> 型
		let swiftArray3:Array = nsArray1 as! [Int]

2、数组的 创建

	// Array 型数组
		    
		// 不赋初值，指定数组内数据为 String 型
		let array1 = [String]()
		
		// 不赋初值，Array<String> 等价于 [String]
		let array2 = Array<String>()
		
		// 不指定数组内数据类型，自动推断
		let array3:Array = ["bei", "jing"]
		
		// 指定数组内数据类型为 String 型
		let array4:Array<String> = ["huan", "ying", "ni"]
		
		// 不指定数组内数据类型，自动推断
		let array5 = ["bei", "jing", "huan", "ying", "ni"]
		
		// 指定数组内数据类型为 Int 型
		let array6:[Int] = [1, 2, 3, 4, 5, 6]
		
		// 指定数组内数据类型为 AnyObject 型
		let array7:[AnyObject] = [1, 2, 3, 4, 5, 6, "happy"]
		
		// 创建二维数组
		let array8:Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
	    
	// NSArray 型数组
		    
		let swiftArray:Array = ["bei", "jing", "nin", "hao"]
		    
		let nsArray1:NSArray = swiftArray
		let nsArray2:NSArray = swiftArray as NSArray
		    
		let nsArray3 = NSArray()
		    
		// array: [AnyObject]
		let nsArray4 = NSArray(array: array7)
		
		// array: [AnyObject]
		let nsArray6 = NSArray(array: ["bei", "jing", "huan", "ying", "ni"])
		
		// array: NSArray
		let nsArray5 = NSArray(array: nsArray2)
		
		// object: AnyObject
		let nsArray7 = NSArray(object: "qian")
		
		// objects: AnyObject...
		let nsArray8 = NSArray(objects: "bei", "jing", "huan", "ying", "ni")
		
		// 从 文件 创建字符串
		let nsArray9:NSArray? = NSArray(contentsOfFile: NSHomeDirectory() + "/Desktop/test.txt")
		
		// 从 Url 创建字符串
		let nsArray10:NSArray? = NSArray(contentsOfURL: NSURL(fileURLWithPath: NSHomeDirectory() + "/Desktop/test.txt"))

3、数组的 长度计算

	// Array 或 NSArray 型数组
	
		let array = ["bei", "jing", "huan", "ying", "ni"]
		    
		let num:Int = array.count

4、数组位置的 获取

	// Array 型字符串
		    
		let array = ["bei", "jing", "huan", "ying", "ni"]
		    
		// 获取起始位置，即 0
		let startIndex = array.startIndex
		
		// 获取结束位置，指 数组最后一个元素的位置
		let endIndex = array.endIndex
		
		// 获取指定位置下标值
		let index = array.startIndex.advancedBy(2)
		
		// 获取下标区间值
		let range = array.startIndex.advancedBy(4)...array.startIndex.advancedBy(6)
		
		// 获取指定位置下标的 前一个值
		let predecessorIndex = array.startIndex.advancedBy(2).predecessor()
		
		// 获取指定位置下标的 后一个值
		let successorIndex = array.startIndex.advancedBy(2).successor()

5、数组元素的 获取

	// Array 型数组
		    
		let array:Array = ["bei", "jing", "huan", "ying", "ni"]
		    
		// 获取数组指定下标的元素
		let obj1:String = array[1]
		
		// 获取数组的第一个元素
		let obj2:String? = array.first
		
		// 获取数组的最后一个元素
		let obj3:String? = array.last
		
		// 获取数组指定范围内的元素
		let obj4 = array[2...4]

	// NSArray 型数组
		    
		let nsArray:NSArray = ["bei", "jing", "huan", "ying", "ni"]
		    
		// 获取指定下标元素，NSArray 中数据类型为 AnyObject
		let obj5:String = nsArray[2] as! String
		
		// 获取数组指定下标的元素
		let obj6:String = nsArray.objectAtIndex(2) as! String
		
		// 获取数组的第一个元素
		let obj7:String = nsArray.firstObject as! String
		
		// 获取数组的最后一个元素
		let obj8:String = nsArray.lastObject as! String
		
		// 获取数组指定范围内的元素
		let obj9 = nsArray.objectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 2)))
		
		// 获取数组指定范围内的元素
		let obj10 = nsArray.subarrayWithRange(NSMakeRange(2, 3))

6、数组下标的 获取

	// Array 型数组
		    
		let array:Array = ["bei", "jing", "huan", "ying", "ni"]
		    
		// 获取指定元素的下标，若元素不存在，返回 nil
		let indexNum1:Int? = array.indexOf("huan")
		  	
	// NSArray 型数组
		    
		let nsArray:NSArray = ["bei", "jing", "huan", "ying", "ni"]
		    
		// 获取指定元素的下标，若元素不存在，返回 Int.max
		let indexNum2:Int = nsArray.indexOfObject("hun")

7、数组的 判断

	// Array 型数组
		    
		let arr1:Array = [1, 3, 5, 8]
		let arr2:Array = [1, 3, 7, 8]
		    
		// 判断两个数组是否相等
		let bl1:Bool = arr1 == arr2
		
		// 判断数组是否为空
		let bl2:Bool = arr1.isEmpty
		
		// 判断数组中是否存在指定的元素
		let bl3:Bool = arr1.contains(55)
		   	
	// NSArray 型数组
		    
		let nsArr1:NSArray = [2, 3, 5, 8]
		let nsArr2:NSArray = [1, 4, 7, 9]
		    
		// 判断两个数组是否相等
		let bl4:Bool = nsArr1.isEqualToArray(nsArr2 as [AnyObject])
		
		// 判断数组中是否存在指定的元素
		let bl5:Bool = nsArr1.containsObject(7)
		
		// 返回两个数组中第一个相同的元素，没有时返回 nil
		let firstObj:AnyObject? = nsArr1.firstObjectCommonWithArray(nsArr2 as [AnyObject])

8、数组元素的组合

	// NSArray 型数组
		    
		let arr1:NSArray = ["bei", "jing", "huan", "ying", "nin"]
		let arr2:NSArray = ["Users", "JHQ0228", "Desktop"]
		    
		// 按指定字符组合
		let str1:String = arr1.componentsJoinedByString(" ")
		
		// 按路径组合
		let str2:String = NSString.pathWithComponents(arr2 as! [String])

9、数组元素的 追加

	// Array 型数组
		    
		var arr1:Array = ["bei", "jing"]
		    
		// 使用 "+" 号连接两个数组
		let arr2 = arr1 + ["huan", "ying", "ni"]
		
		// 在数组末尾追加一个元素
		arr1.append("hao")
		
		// 在指定位置插入一个元素
		arr1.insert("ni", atIndex: 2)
		  	
	// NSArray 型数组
		    
		let nsArray:NSMutableArray = ["jing", "huan"]
		    
		// 向数组添加一个元素，返回一个新的数组
		let nsArray1 = nsArray.arrayByAddingObject("ma")
		
		// 在数组末尾追加一个元素
		nsArray.addObject("ni")
		
		// 在数组末尾追加一个数组
		nsArray.addObjectsFromArray(["ni", "hao"])
		
		// 在指定位置追加一个元素
		nsArray.insertObject("bei", atIndex: 0)

10、数组元素的 删除

	// Array 型数组
		    
		var arr1:Array = ["bei", "jing", "huan", "ying", "ni"]
		    
		// 删除指定位置的数组元素
		arr1.removeAtIndex(3)
		
		// 删除数组中的最后一个元素
		arr1.removeLast()
		
		// 删除指定范围内的数组元素
		arr1.removeRange(0...1)
		
		// 删除所有数组元素
		arr1.removeAll(keepCapacity: true)
		   	
	// NSArray 型数组
		    
		let nsArr1:NSMutableArray = ["nan", "jing", "huan", "ying", "nin", "bei", "jing", "ni", "hao"]
		    
		// 删除指定下标的元素
		nsArr1.removeObjectAtIndex(2)
		
		// 删除指定元素，删除所有指定元素
		nsArr1.removeObject("ying")
		
		// 删除指定元素
		nsArr1.removeObjectIdenticalTo("nan")
		
		// 删除最后一个元素
		nsArr1.removeLastObject()
		
		// 删除指定范围的元素
		nsArr1.removeObjectsInRange(NSMakeRange(2, 1))
		
		// 删除所有元素
		nsArr1.removeAllObjects()

11、数组元素的 替换

	// NSArray 型数组
		    
		let nsArr:NSMutableArray = ["nan", "jing", "huan", "ying", "nin"]
		    
		// 替换指定下标元素
		nsArr.replaceObjectAtIndex(0, withObject: "bei")
		
		// 替换的元素个数与被替换的元素个数需相等
		nsArr.replaceObjectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 3)), 
		                  withObjects: ["ni", "hao", "ma"])
		
		// 用数组替换
		nsArr.replaceObjectsInRange(NSMakeRange(2, 3), withObjectsFromArray: ["huan", "ying"])
		  	
		nsArr.replaceObjectsInRange(NSMakeRange(0, 2), 
		       withObjectsFromArray: ["huan", "ying", "nin", "nan", "jing", "huan"], 
		                      range: NSMakeRange(3, 2))

12、数组元素的 交换

	// NSArray 型数组
	let nsArr:NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]
	    
	nsArr.exchangeObjectAtIndex(2, withObjectAtIndex: 4)

13、数组元素的 修改

	// Array 型数组
		
		var arr:Array = ["bei", "jing", "huan", "ying", "ni"]
		    
		arr[0] = "nan"
		  	
		// NSArray 型数组
		let nsArr:NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]
		    
		// 修改数组中的某个元素
		nsArr[4] = "ni"
		
		// 修改整个数组（覆盖重写）
		nsArr.setArray(["ni", "hao"])

14、数组元素的 过滤

	// Array 型数组
		    
		let arr:Array = [1, 9, 2, 8, 45]
		    
		let array:[Int] = arr.filter { (obj:Int) -> Bool in
		    
			// 过滤掉不能被 3 整除的数
			return obj % 3 == 0
		}
			
	// NSArray 型数组
		    
		let nsArr:NSMutableArray = [1, 9, 2, 8, 45]
		    
		let nsArray:[AnyObject] = nsArr.filter { (obj:AnyObject) -> Bool in
		    
			// 过滤掉不能被 3 整除的数
			return (obj as! Int) % 3 == 0
		}

15、数组的遍历

• 用 for...in 循环遍历

  	// Array 或 NSArray 型数组
  		
  		let arr = ["bei", "jing", "huan", "ying", "ni"]
  		    
  		// tmp 无需定义，在 Swift 2.2 中 C 语言样式的 for 循环语句被废弃
  		for tmp in arr {
  		    
  			print(tmp)
  		}
  

• 用闭包循环遍历

  	// NSArray 型数组
  		
  		let arr:NSArray = ["bei", "jing", "huan", "ying", "ni"]
  		    
  		arr.enumerateObjectsUsingBlock { (obj:AnyObject, idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in
  			    
  			print(obj)
  			    
  			if obj.isEqualTo("huan") {
  				    
  				// 停止继续遍历
  				stop.initialize(true)
  			}
  		}
  

• 用迭代器遍历

  	// NSArray 型数组
  		    
  		let arr:NSArray = ["bei", "jing", "huan", "ying", "ni"]
  		    
  		// 正序遍历
  		let enu1:NSEnumerator = arr.objectEnumerator()
  
  		// 反序遍历
  		let enu2:NSEnumerator = arr.reverseObjectEnumerator()
  
  		// AnyObject 后不要加 ？，否则会导致一直循环
  		while let obj:AnyObject = enu1.nextObject() {
  		    
  			print(obj)
  		}
  

• 条件遍历

  	// NSArray 型数组
  		
  		let arr:NSArray = ["bei", "jing", "huan", "ying", "huan", "ni"]
  
  		// 1. indexesOfObjectsPassingTest 找出数组中所有满足条件的值
  			    
  			let indexSet:NSIndexSet = arr.indexesOfObjectsPassingTest { (obj:AnyObject, 
  			                                                             idx:Int, 
  			                                                            stop:UnsafeMutablePointer<ObjCBool>) -> Bool in
  			    
  				// 条件满足时返回满足的数组元素的下标
  				return obj.isEqualTo("huan") ? true : false
  			}
  			    
  			indexSet.enumerateIndexesUsingBlock { (idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in
  				  
  				print(idx)
  			}
  
  		// 2. indexOfObjectPassingTest 找出数组中第一个满足条件的值
  			    
  			let index:Int = arr.indexOfObjectPassingTest { (obj:AnyObject, 
  			                                                idx:Int, 
  			                                               stop:UnsafeMutablePointer<ObjCBool>) -> Bool in
  			  
  				// 条件满足时返回满足的数组元素的下标
  				return obj.isEqualTo("huan") ? true : false
  			}
  
  			print(index)
  

16、数组的排序

• 冒泡排序

  	// NSArray 型数组
  		
  		let array:NSMutableArray = ["bei", "jing", "huan", "ying", "ni"]
  		    
  		for i in 0 ..< array.count - 1 {
  			for j in 0 ..< array.count - 1 - i {
  				    
  				// 大小判断 升序
  				if (array[j] as! String).compare(array[j + 1] as! String) == NSComparisonResult.OrderedAscending {
  					
  					// 位置交换
  					array.exchangeObjectAtIndex(j, withObjectAtIndex: j + 1)
  				}
  			}
  		}
  		print(array)
  

• 用闭包排序

  	// Array 型数组
  		    
  		// 1. 利用闭包进行排序，可变数组排序
  			    
  			var varArray:Array = ["sunday", "sunny", "summer", "sun"];
  				    
  			varArray.sortInPlace { (obj1:String, obj2:String) -> Bool in
  				    
  				return obj1 < obj2
  			}
  			    
  			print(varArray)
  			  	
  		// 2. 利用闭包进行排序，不可变数组排序
  			    
  			let letArray:Array = ["sunday", "sunny", "summer", "sun"];
  			    
  			let array = letArray.sort { (obj1:String, obj2:String) -> Bool in
  			    
  				return obj1 < obj2
  			}
  			    
  			print(array)
      
  	// NSArray 型数组
  		    
  		// 1. 利用闭包进行排序，可变数组排序
  			    
  			let nsMArray1:NSMutableArray = ["sunday", "sunny", "summer", "sun"];
  			    
  			nsMArray1.sortUsingComparator { (obj1:AnyObject, obj2:AnyObject) -> NSComparisonResult in
  				    
  				let result:NSComparisonResult = (obj1 as! String).compare(obj2 as! String)
  				    
  				return result
  			}
  			    
  			print(nsMArray1)
  			    
  		// 2. 利用闭包进行排序，不可变数组排序
  			    
  			let nsArray1:NSArray = ["sunday", "sunny", "summer", "sun"];
  			    
  			let array1:NSArray = nsArray1.sortedArrayUsingComparator { (obj1:AnyObject, 
  			                                                            obj2:AnyObject) -> NSComparisonResult in
  				    
  				let result:NSComparisonResult = (obj1 as! String).compare(obj2 as! String)
  				    
  				return result
  			}
  			    
  			print(array1)
  

• 用指定的方法排序

  	// Array 型数组
  		    
  		// 1. 用指定的方法排序，可变数组排序
  			    
  			var varArray:Array = ["sunday", "sunny", "summer", "sun"];
  			    
  			// 直接使用 Swift 数组类型中定义的小于号 (<) 实现，public func <(lhs: String, rhs: String) -> Bool
  			varArray.sortInPlace( < )
  			    
  			print(varArray)
  			    
  		// 2. 用指定的方法排序，不可变数组排序
  			    
  			let letArray:Array = ["sunday", "sunny", "summer", "sun"];
  			    
  			// 直接使用 Swift 数组类型中定义的小于号 (<) 实现，public func <(lhs: String, rhs: String) -> Bool
  			let array = letArray.sort( < )
  			    
  			print(array)
  			    
  	// NSArray 型数组
  
  		// 1. 用指定的方法排序，可变数组排序
  			    
  			let nsMArray1:NSMutableArray = ["sunday", "sunny", "summer", "sun"];
  			    
  			// 原数组的顺序改变，指定元素的比较方法：compare:，默认为升序排列，
  			// #selector(NSNumber.compare(_:)) 代替 Selector("compare:")
  			nsMArray1.sortUsingSelector(#selector(NSNumber.compare(_:)))
  			                                                                    
  			print(nsMArray1)
  			    
  			// 使排序结果 降序 排列
  			let enu:NSEnumerator = nsMArray1.reverseObjectEnumerator()
  			    
  			while let obj:AnyObject = enu.nextObject() {
  				print(obj)
  			}
  			    
  		// 2. 用指定的方法排序，不可变数组排序
  			    
  			let nsArray1:NSArray = ["sunday", "sunny", "summer", "sun"];
  			
  			// 返回一个排好的数组，原数组的顺序不变，指定元素的比较方法：compare:
  			let array1:NSArray = nsArray1.sortedArrayUsingSelector(#selector(NSNumber.compare(_:)))
  			
  			print(array1)
  			    
  		// 3. 用指定的方法排序，自定义类
  
  			// Student.swift
  
  				class Student: NSObject {
                  
  					var firstName:String
  					var lastName:String
                  
  					init(firstName:String, lastName:String ) {
                      
  						self.firstName = firstName
  						self.lastName = lastName
  					}
                  
  					func compareStudent(stu:Student) -> NSComparisonResult {
                      
  						// 先按照姓排序
  						var result:NSComparisonResult = self.lastName.compare(stu.lastName)
                      
  						if result == NSComparisonResult.OrderedSame {
                          
  							// 如果有相同的姓，就比较名字
  							result = self.firstName.compare(stu.firstName)
  						}
  						return result;
  					}
                  
  					// 需遵守协议 Printable
  					override var description: String{
                      
  						return String(format: "%@, %@", self.lastName, self.firstName)
  					}
  				}
  
  			// main.swift
  
  				let stu1:Student = Student(firstName: "MingJie", lastName: "Li")
  				let stu2:Student = Student(firstName: "LongHu", lastName: "Huang")
  				let stu3:Student = Student(firstName: "LianJie", lastName: "Li")
  				let stu4:Student = Student(firstName: "Jian", lastName: "Xiao")
          
  				// 用指定的方法排序，可变数组排序
  				
  					let nsMArray2:NSMutableArray = NSMutableArray(objects: stu1, stu2, stu3, stu4)
          
  					// 代替 Selector("compareStudent:")
  					nsMArray2.sortUsingSelector(#selector(Student.compareStudent(_:)))
  
  					print(nsMArray2)
          
  				// 用指定的方法排序，不可变数组排序
  				
  					let nsArray2:NSArray = NSArray(objects: stu1, stu2, stu3, stu4)
          
  					let array2:NSArray = nsArray2.sortedArrayUsingSelector(#selector(Student.compareStudent(_:)))
  					
  					print(array2)
  

• 按描述器排序

  	// Student.swift
  
  		class Student: NSObject, Printable {
  
  			var firstName:String
  			var lastName:String
  
  			init(firstName:String, lastName:String ) {
  
  				self.firstName = firstName
  				self.lastName = lastName
  			}
  
  			override var description: String{
  
  				return String(format: "%@, %@", self.lastName, self.firstName)
  			}
  		}
  
  	// main.swift
  
  		let stu1:Student = Student(firstName: "MingJie", lastName: "Li")
  		let stu2:Student = Student(firstName: "LongHu", lastName: "Huang")
  		let stu3:Student = Student(firstName: "LianJie", lastName: "Li")
  		let stu4:Student = Student(firstName: "Jian", lastName: "Xiao")
      
  		// 先按照姓进行排序
  		let lastnNmeDesc:NSSortDescriptor = NSSortDescriptor(key: "lastName", ascending: true)
      
  		// 再按照名进行排序
  		let firstNameDesc:NSSortDescriptor = NSSortDescriptor(key: "firstName", ascending: true)
      
  		// 1.按描述器排序，可变数组排序
      
  			let array1 = NSMutableArray(objects: stu1, stu2, stu3, stu4)
          
  			// 按顺序添加排序描
  			let descs1 = NSArray(objects: lastnNmeDesc, firstNameDesc)
          
  			array1.sortUsingDescriptors(descs1 as! [NSSortDescriptor])
      
  			print(array1)
      
  		// 2.按描述器排序，不可变数组排序
      
  			let array2 = NSArray(objects: stu1, stu2, stu3, stu4)
          
  			// 按顺序添加排序描
  			let descs2 = NSArray(objects: lastnNmeDesc, firstNameDesc)
          
  			let array3 = array2.sortedArrayUsingDescriptors(descs2 as! [NSSortDescriptor])
          
  			print(array3)