iOS - Swift Array 数组

时间 2020-06-07

标签 ios swift array 数组栏目 iOS 繁體版

原文原文链接

前言

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

在 Swift 语言中，数据在被存储进某个数组以前，类型必须明确，且与数组其余元素类型相同。在 Swift 语言中的数组和 C 语言中的不一样，Swift 语言中的数组是值类型的，无论是赋值仍是看成参数传递，都只是维护他的拷贝。你能够放心的操做他的拷贝，由于你作的任何操做都不会反馈回它自己，这是值类型自身的规则。

一、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]

二、数组的建立

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

三、数组的长度计算

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

四、数组位置的获取

// 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()

五、数组元素的获取

// 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))

六、数组下标的获取

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

七、数组的判断

// 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])

八、数组元素的组合

// 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])

九、数组元素的追加

// 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)

十、数组元素的删除

// 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()

十一、数组元素的替换

// 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))

十二、数组元素的交换

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

1三、数组元素的修改

// 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"])

1四、数组元素的过滤

// 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
		}

1五、数组的遍历

用 for...in 循环遍历swift

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

条件遍历app

// 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)

1六、数组的排序

冒泡排序ide

// 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)

用闭包排序code

// 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)

用指定的方法排序component

// 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)

按描述器排序orm

// 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)

iOS - Swift Array 数组

前言

一、Array 与 NSArray 的相互转换

二、数组的 建立

三、数组的 长度计算

四、数组位置的 获取

五、数组元素的 获取

六、数组下标的 获取

七、数组的 判断

八、数组元素的组合

九、数组元素的 追加

十、数组元素的 删除

十一、数组元素的 替换

十二、数组元素的 交换

1三、数组元素的 修改

1四、数组元素的 过滤

1五、数组的遍历

1六、数组的排序

二、数组的建立

三、数组的长度计算

四、数组位置的获取

五、数组元素的获取

六、数组下标的获取

七、数组的判断

九、数组元素的追加

十、数组元素的删除

十一、数组元素的替换

十二、数组元素的交换

1三、数组元素的修改

1四、数组元素的过滤