array内部排序 ios
2012-01-07 17:33:19 nong1209 阅读数 1695
*** Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <__NSArrayM: 0x12ec10e0> was mutated while being enumerated.'

用个for循环去读取一个数组A,然后删除一些元素的操作,就会出现上面的错误


这个是因为一个数组不能同时有一个线程去读取,然后另个线程去写


所以出错


B arraywithArray:A


读完了,再写就可以了
2013-09-17 11:41:23 ipoolo 阅读数 11

转自:https://github.com/yidaizhenlong/LQRequest/issues/1

NSMutableArray array=[[NSMutableArray alloc] initWithObjects:@"a",@"b", nil];

NSMutableArray *deepCopyArray=[[NSMutableArray alloc] initWithArray: array copyItems: YES];

NSMutableArray trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:

[NSKeyedArchiver archivedDataWithRootObject: array]];

 

    [[trueDeepCopyArray objectAtIndex:0] appendString:@"trueDeepCopyArray"];

image

//trueDeepCopyArray是完全意义上的深拷贝,而deepCopyArray则不是,对于deepCopyArray内的不可变元素其还是指针复制。或者我们自己实现深拷贝的方法。因为如果容器的某一元素是不可变的,那你复制完后该对象仍旧是不能改变的,因此只需要指针复制即可。除非你对容器内的元素重新赋值,否则指针复制即已足够。

心得:copy方法,得到的是不可变对象,不管以前的是可变还是不可变。mutableCopy方法,得到的是可变对象,不管以前的是可变还是不可变。

2013-11-14 10:50:00 weixin_30527143 阅读数 1

 

 

NSArray *sortedArray = [array sortedArrayUsingComparator: ^(id obj1, id obj2) {

    if ([obj1 integerValue] > [obj2 integerValue]) {
        return (NSComparisonResult)NSOrderedDescending;
    }

    if ([obj1 integerValue] < [obj2 integerValue]) {
        return (NSComparisonResult)NSOrderedAscending;
    }
    return (NSComparisonResult)NSOrderedSame;
}];

 

 

转载于:https://www.cnblogs.com/lingzhao/p/3422874.html

2015-01-26 13:03:00 weixin_33774615 阅读数 2

        NSArray *array = [NSArray array];

       NSPredicate *predicate = [NSPredicate predicateWithFormat:@"self.msgid == %@",feed.msgid];


        NSArray *filterArr = [array filteredArrayUsingPredicate:predicate];


  1.         NSPredicate *predicate1=[NSPredicate predicateWithFormat:@"name=='holydancer'"];//创建谓词判断属性  
  2.         NSPredicate *predicate2=[NSPredicate predicateWithFormat:@"child.age==5"];//创建谓词判断属性的属性  


2016-08-16 18:26:00 weixin_33676492 阅读数 16

前言

    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)
没有更多推荐了,返回首页