• 1.保存数组到文件中 //MARK:1,数组(Array)的存储和读取 func testSaveArrayPlist() { let arry = NSArray(objects: "stev","baidu.com","com","12344","robinson") let filePath:String = NSHomeDirectory()...

    1.保存数组到文件中

     //MARK:1,数组(Array)的存储和读取
        func testSaveArrayPlist() {
            let arry = NSArray(objects: "stev","baidu.com","com","12344","robinson")
            let filePath:String = NSHomeDirectory() + "/Documents/tf.plist"
            arry.writeToFile(filePath, atomically: true)
            
            tfArray = NSArray(contentsOfFile:NSHomeDirectory() + "/Documents/tf.plist")
            
            print(tfArray)
        }
    


    数组打印结果如下:
    Optional(<__NSCFArray 0x7dbba000>(
    stev,
    baidu.com,
    com,
    12344,
    robinson
    )
    )


    2.保存字典到文件中

    func testSaveDicPlist(){
            let  myArray = [
                
                [
                    ["name":"小明" , "url":"google.com"],
                    ["name":"张三", "url":"tf234.com"],
                    ["name":"里斯" , "url":"csdn.com"]
                ],
                
                [
                    ["name":"张三", "url":"tf234.com"],
                    ["name":"里斯" , "url":"csdn.com"]
                ]
            ]
            
            let filePath:String = NSHomeDirectory() + "/Documents/tfDic.plist"
            NSArray(array: myArray).writeToFile(filePath, atomically: true)
            print(filePath)
            
            tfArray = NSArray(contentsOfFile:NSHomeDirectory() + "/Documents/tfDic.plist")
            
            print(tfArray)
        }
    

    字典打印结果如下:

    Optional(<__NSCFArray 0x7aa6f4a0>(
    <__NSCFArray 0x7aa6df50>(
    {
        name = "\U822a\U54e5";
        url = "hangge.com";
    },
    {
        name = "\U767e\U5ea6";
        url = "baidu.com";
    },
    {
        name = google;
        url = google;
    }
    )
    ,
    <__NSCFArray 0x7aa70de0>(
    {
        name = 163;
        url = "163.com";
    },
    {
        name = google;
        url = "google.com";
    }
    )
    
    )
    )
    


    展开全文
  • Swift提供了两种集合类型来存放多个值——数组(Array)和字典(Dictionary)。数组把相同类型的值存放在一个有序链表里。字典把相同类型的值存放在一个无序集合里,这些值可以通过唯一标识符(也就是键)来引用和查找。...
    Swift提供了两种集合类型来存放多个值——数组(Array)和字典(Dictionary)。数组把相同类型的值存放在一个有序链表里。字典把相同类型的值存放在一个无序集合里,这些值可以通过唯一标识符(也就是键)来引用和查找。

    在Swift里,数组和字典里所能存放的值的类型是明确的。这意味着你不能误把一个错误类型的值添加到数组或字典里,也意味着你可以明白无误地知道从数组或字典里取得的值会是什么类型的。Swift集合是类型明确的,这保证了你的代码会清楚地知道它们所能处理的值的类型,并让你能在代码开发阶段就发现任何输入错误。
    注意: Swift的数组在赋值给常量、变量或者传值给函数、方法时,它的行为表现和其它类型并不一样。详情参见可变集合集合类型的赋值和拷贝行为

    数组(Array)

    数组在一个有序链表里存储了多个类型相同的值。同一个值可以在数组的不同位置出现多次。

    Swift的数组对它们能存放的值的类型是明确的。这不同于Objective-C的NSArray类和NSMutableArray类,Objective-C的数组能存储任何类型的对象,并且不提供关于这些对象自身的任何信息。在Swift里,任何一个特定的数组所能存储的值,其类型总会被确定下来,或者通过显式的类型说明,或者通过类型推断,并且该类型不必是类类型。例如,如果你创建了一个Int型数组,你就不能把任何非Int型的值插入这个数组。Swift数组是类型安全的,它总是知道它能存储什么值。

    数组类型的简写语法

    Swift数组的类型是Array<SomeType>,这里的SomeType是某种数组能够存放的类型。你也可以把数组类型简写为SomeType[]。尽管这两种形式功能上是一样的,我们更偏向于使用简写形式,本书里所有数组类型都是使用简写形式。

    数组字面量

    可以用一个数组字面量来初始化一个数组,简单地把一个或多个值放在一起就可以了。数组字面量的写法是一行用逗号隔开的值,并在行的两端用一对方括号包起来:
        [value 1, value 2, value 3]

    下面的例子创建了一个存放String类型值,名为shoppingList的数组:
    1. var shoppingList: String[] = ["Eggs", "Milk"]
    2. // shoppingList 用两个元素完成初始化
    根据String[],变量shoppingList被声明为“一个存放String值的数组”。因为这个数组指明了值类型为String,所以它只能存放String类型的值。这里的shoppingList数组使用了一个数组字面量来初始化,该数组字面量含有两个String类型的元素("Eggs"和"Milk")。
    注意:数组shoppingList被声明为变量(用关键字var)而不是常量(用关键字let),是因为在下面的例子中会往这个购物清单里添加更多的元素。
    在本例中,这个数组字面量只包含了两个String值。这和shoppingList变量定义中的类型一致(一个存放String值的数组),所以可以把这个数组字面量直接赋值给shoppingList进行初始化。

    得益于Swift的类型推断,如果使用数组字面量来初始化一个数组,这个数组字面量里的值具有相同的类型,你可以不必明确写出这个数组的类型。上面初始化shoppingList的代码可以简写为:
    1. var shoppingList = ["Eggs", "Milk"]
    因为数组字面量中的所有值具有相同的类型,Swift可以推断出shoppingList变量的类型就是String[]。

    数组的存取与修改

    对数组的存取与修改可以通过数组的方法和属性来进行,或者使用数组的下标语法。

    要知道数组中元素的数量,可以查看它的只读属性count:
    1. println("The shopping list contains \(shoppingList.count) items.")
    2. // 输出“The shopping list contains 2 items.”
    使用Boolean型的isEmpty属性,可以快速检查count属性是否为0:
    1. if shoppingList.isEmpty {
    2. println("The shopping list is empty.")
    3. } else {
    4. println("The shopping list is not empty.")
    5. } // 输出“The shopping list is not empty.”
    往数组的末尾添加一个元素,可以调用数组的append方法:
    1. shoppingList.append("Flour")
    2. // shoppingList现在包含3个元素了,看起来有人要摊薄饼啊
    往数组末尾添加一个元素,也可以使用+=操作符:
    1. shoppingList += "Baking Powder"
    2. // shoppingList现在包含4个元素了
    你也可以使用+=操作符把一个类型相同的数组连接到数组后面:
    1. shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
    2. // shoppingList现在包含7个元素了
    从数组取得一个值可以使用下标语法。在数组名后面紧跟着的一对方括号中,传进去要取得的元素的索引值:
    1. var firstItem = shoppingList[0]
    2. // firstItem 等于 "Eggs"
    要注意数组第一个元素的索引值为0,而不是1。Swift的数组总是从0开始索引的。

    你可以使用下标语法来改变给定索引的已存在的值:
    1. shoppingList[0] = "Six eggs"
    2. // 这个清单的第一项现在是“Six eggs”了,而不是"Eggs"
    你可以使用下标语法一次性改变指定范围的值,即使将要被替换掉的元素的数量和将要替换成的元素的数量不一样。下面的例子将"Chocolate Spread","Cheese"和 "Butter"替换为"Bananas"和"Apples"
    1. shoppingList[4...6] = ["Bananas", "Apples"] // shoppingList现在包含6个元素
    注意: 不能使用下标语法添加新元素到数组末尾。如果试图使用超出数组范围的下标来取用或存放一个元素,会产生运行时错误。在使用一个索引值之前,应该把它跟数组的count属性进行比较,以检测它是否有效。除非count是0(意味着这是个空数组),数组的最大有效索引总是count - 1,因为数组的索引是从0开始的。
    插入一个元素到特定位置,可以调用数组的insert(atIndex:)方法:
    1. shoppingList.insert("Maple Syrup", atIndex: 0)
    2. // shoppingList现在包含7个元素
    3. // 清单的第一个元素现在是"Maple Syrup"
    本次调用insert函数,通过指明的下标0,向购物清单的开头添加了一个值为"Maple Syrup"的新元素。

    类似地,你可以使用removeAtIndex方法从数组删除一个元素。该方法删掉指定索引上的元素,并返回这个被删掉的元素(如果你不需要返回值,可以忽略它):
    1. let mapleSyrup = shoppingList.removeAtIndex(0)
    2. // 索引为0的元素已从数组中删掉了
    3. // shoppingList现在包含6个元素,不包含"Maple Syrup"
    4. // 常量mapleSyrup现在等于被删掉的字符串"Maple Syrup"
    当一个元素被删除时,数组中的不会留下任何空白无元素的地方。所以在索引0处的元素又变为"Six eggs"了:
    1. firstItem = shoppingList[0]
    2. // firstItem现在等于"Six eggs"
    如果想删除数组的最后一个元素,可以使用removeLast方法,而不必使用removeAtIndex方法,这样就可以避免还得调用数组的count属性。类似removeAtIndex方法,removeLast方法也返回被删除的元素:
    1. let apples = shoppingList.removeLast() // 数组的最后一个元素被删除了 // shoppingList现在包含5个元素,不包含"cheese" // 常量apples现在等于被删掉的字符串"Apples"

    数组的迭代访问

    你可以通过for-in循环来迭代访问整个数组的值。
    1. for item in shoppingList {
    2. println(item)
    3. }
    4. // Six eggs
    5. // Milk
    6. // Flour
    7. // Baking Powder
    8. // Bananas
    如果要获得每个元素的索引及其对应的值,可以使用全局的enumerate方法来迭代使用这个数组。enumerate方法对每个元素都会返回一个由索引值及对应元素值组成的元组。你可以把元组中的成员转为变量或常量来使用:
    1. for (index, value) in enumerate(shoppingList) {
    2. println("Item \(index + 1): \(value)")
    3. }
    4. // Item 1: Six eggs
    5. // Item 2: Milk
    6. // Item 3: Flour
    7. // Item 4: Baking Powder
    8. // Item 5: Bananas
    要获得关于for-in循环的更多资料,请查看For Loops

    数组创建与初始化

    可以通过初始化语法创建一个特定类型的空数组,数组中不包含任何初始值:
    1. var someInts = Int[]()
    2. println("someInts is of type Int[] with \(someInts.count) items.")
    3. // 输出 "someInts is of type Int[] with 0 items.
    要注意变量someInts会被推断为Int[]类型,因为它接收的是Int[]型初始化函数的返回值。

    并且,如果上下文中已经提供了类型信息,例如方法的参数、已经定义类型的常量或变量,你就可以使用一个空的数组字面量来创建一个空的数组。空的数组字面量被写为[],就是一对不包括任何内容的方括号。
    1. someInts.append(3)
    2. // someInts现在包含了一个整型值 someInts = []
    3. // someInts现在成为了一个空数组,但其类型仍然是Int[]
    Swift的数组还提供了一个生成若干个重复元素组成的数组的初始化函数。把要添加到新数组里的元素数量(count)和一个合适的默认值(repeatedValue)传参给该初始化函数即可:
    1. var threeDoubles = Double[](count: 3, repeatedValue: 0.0)
    2. // threeDoubles类型为Double[],值为[0.0, 0.0, 0.0]
    得益于Swift的类型推断,在使用这个初始化函数的时候,不必精确说明该数组的类型,因为这能从默认值中推断出来:
    1. var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
    2. // anotherThreeDoubles的类型被推断为Double[],值为[2.5, 2.5, 2.5]

    字典(Dictionary)

    字典是一种存储多个类型相同的值的容器。每个值都和一个唯一的键相对应,这个键在字典里就是其对应值的唯一标识。跟数组不同,字典里的元素并没有特定的顺序。在“字典”中使用键来查询其对应值的方式,跟在“现实世界的字典”中使用单词查询单词定义差不多。

    Swift的字典对它们能存放的键和值的类型是明确的。这不同于Objective-C的NSDictionary类和NSMutableDictionary类,Objective-C的字典能存储任何类型的对象作为键或值,并且不提供关于这些对象自身的任何信息。在Swift里,任何一个特定的字典键和值,其类型总会被确定下来,或者通过显式的类型说明,或者通过类型推断。

    Swift的字典类型是Dictionary<KeyType, ValueType>,其中KeyType是字典中键的类型,ValueType是字典中值的类型。

    对键类型KeyType的唯一限制是,它必须是可哈希的,也就是说,它必须能够提供一个方式让自己被唯一表示出来。Swift的所有基础类型(例如String、Int、Double和Bool)默认都是可哈希的,这些类型都能够用作字典中的键。枚举成员中没有绑定值的值(参见枚举)默认也是可哈希的。

    字典字面量

    可以用一个字典字面量来初始化一个数组,其语法格式类似于之前看到的数组字面量。字典字面量是写一个具有单个或多个键值对字典的简便方法。

    键值对是一个键和一个值的组合。在字典字面量中,每对键值对中的键和值使用冒号分开,键值对之间用逗号分开,用一对方括号将这些键值对包起来:
        [key 1: value 1,  key 2: value 2,  key 3: value 3]

    下面的例子创建了一个存储国际机场名字的字典,在这个字典中,键是三字母的国际航空运输协会码,值是机场的名字:
    1. var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]
    airports被定义为一个Dictionary<String, String>类型的字典,也就是“一个键的类型为String,值的类型也为String的字典”。
    注意:字典airports被声明为变量(用关键字var)而不是常量(用关键字let),是因为在下面的例子中会往这个字典里添加更多的机场。
    这里的字典airports使用了一个字典字面量来初始化,该字典字面量含有两个键值对,第一对的键为"TYO"、值为"Tokyo",第二对的键为"DUB"、值为"Dublin"。

    在本例中,此数组字面量只包含了两个String: String键值对。这和airports变量定义中的类型一致(键的类型为String,值的类型也为String),所以可以把这个字典字面量直接赋值给airports进行初始化。

    就像数组一样,如果使用具有相应类型的键和值的字典字面量来对字典进行初始化,你可以不必明确写出这个字典的类型。上面初始化airports的代码可以简写为:
    1. var airports = ["TYO": "Tokyo", "DUB": "Dublin"]
    因为这个字典字面量中的所有键具有相同的类型,所有值也具有相同的类型,Swift可以推断出airports变量的类型就是Dictionary<String, String>。

    字典的存取与修改

    对字典的存取与修改可以通过字典的方法和属性来进行,或者使用字典的下标语法。就像数组一样,可以通过只读属性count获得Dictionary中元素的数量:
    1. println("The dictionary of airports contains \(airports.count) items.")
    2. // 输出"The dictionary of airports contains 2 items."
    可以使用下标语法向字典中添加新的元素。以一个合适类型的新键作为下标索引,并且赋给它一个合适类型的值:
    1. airports["LHR"] = "London"
    2. // 字典airports现在包含3个元素
    也可以使用下标语法来改动某个键对应的值:
    1. airports["LHR"] = "London Heathrow"
    2. // "LHR"的值被改为"London Heathrow
    在对特定键设置或更新值时,也可以使用updateValue(forKey:)函数来替代下标。就像上面例子中的下标语法,updateValue(forKey:)函数在键不存在的时候就设置一个新值,在键存在的时候就更新该值。和下标语法不一样的是,updateValue(forKey:)函数在更新一个值之后,会返回原来的老值。这让你能够检测是否发生了值的更新。

    updateValue(forKey:)函数返回一个值的类型的可选值。例如一个值类型为String的字典,该函数返回值的类型为String?。如果更新前该键的值存在,函数返回值就是该键更新前的值,如果不存在,函数返回值就是nil:
    1. if let oldValue = airports.updateValue("Dublin International", forKey: "DUB") {
    2. println("The old value for DUB was \(oldValue).")
    3. }
    4. // 输出 "The old value for DUB was Dublin.
    你也可以使用下标语法从字典中对一个特定的键取值。因为可能会用到一个没有对应值存在的键,所以字典的下标语法返回的也是该字典值类型的可选值。如果字典中有该键对应的值,下标语法就返回该值,如果不存在,下标语法就返回nil:
    1. if let airportName = airports["DUB"] {
    2. println("The name of the airport is \(airportName).")
    3. } else {
    4. println("That airport is not in the airports dictionary.")
    5. }
    6. // 输出 "The name of the airport is Dublin International."
    也可以使用下标语法把一个键对应的值赋为nil来删除该键值对:
    1. airports["APL"] = "Apple International"
    2. // "Apple International" 不是APL的机场,所以要删除它 airports["APL"] = nil
    3. // APL键值对已经从字典中删除了
    从字典中删除键值对也可以使用removeValueForKey函数。如果该键值对存在,该函数就返回本删掉的值,如果不存在,就返回nil:
    1. if let removedValue = airports.removeValueForKey("DUB") {
    2. println("The removed airport's name is \(removedValue).")
    3. } else {
    4. println("The airports dictionary does not contain a value for DUB.")
    5. }
    6. // 输出 "The removed airport's name is Dublin International."

    字典的迭代访问

    你可以通过for-in循环来迭代访问整个字典的键值对。它会对字典中的每个元素都会返回一个(key, value)元组,你可以把元组中的成员转为变量或常量来使用:
    1. for (airportCode, airportName) in airports {
    2. println("\(airportCode): \(airportName)")
    3. }
    4. // TYO: Tokyo // LHR: London Heathrow
    要获得关于for-in循环的更多资料,请查看For Loops

    可以通过字典的keys属性和values属性,获得一个可以迭代访问的集合:
    1. for airportCode in airports.keys {
    2. println("Airport code: \(airportCode)")
    3. }
    4. // Airport code: TYO
    5. // Airport code: LHR
    6. for airportName in airports.values {
    7. println("Airport name: \(airportName)")
    8. }
    9. // Airport name: Tokyo
    10. // Airport name: London Heathrow
    如果你需要将字典的所有键或者所有值放到一个Array对象里,可以直接使用字典的keys属性或者values属性:
    1. let airportCodes = Array(airports.keys)
    2. // airportCodes为["TYO", "LHR"]
    3. let airportNames = Array(airports.values)
    4. // airportNames为["Tokyo", "London Heathrow"]
    注意: Swift的Dictionary类型不是一个有序集合,迭代访问字典的keys、values、键值对时候的顺序并无具体规定。

    生成一个空字典

    像数组一样,你可以使用初始化语法创建一个特定类型的空Dictionary:
    1. var namesOfIntegers = Dictionary<Int, String>()
    2. // namesOfIntegers是一个Dictionary<Int, String>类型的空字典
    这个例子创建了一个存储数字名称的空字典,键的类型是Int,值的类型是String。

    如果上下文中已经提供了类型信息,可以使用空字典字面量[:]来创建一个空字典:
    1. namesOfIntegers[16] = "sixteen"
    2. // namesOfIntegers现在含有1个键值对
    3. namesOfIntegers = [:]
    4. // namesOfIntegers又成为一个类型为Int,String的空字典
    注意: 实际上,Swift的数组和字典类型是通过泛型集合实现的。要获得关于泛型类型和集合的更多资料,请查看Generics

    集合的可变性

    数组和字典都把多个值存放在一个集合里。如果你创建了一个数组或者字典,并且将之指定为变量,那么该集合就是可变的,这意味着在集合被创建后,可以通过增加或删除元素来改变集合的容量大小。相反地,如果你指定一个数组或字典为常量,那么该数组或字典就是不可变的,其容量大小不能被改变。

    对字典来说,不可变还意味着你不能改变字典里某个键的值。一个不可变的字典一旦被设置值后,它里面的内容就不能再改变。

    但是,数组的不可变性跟字典略有不同。尽管你不能进行任何可能会改变数组大小的操作,但是你可以给数组中的某个索引设置一个新的值。这使得Swift的数组在大小固定的情况下能够达到最佳的性能。

    Swift数组类型的可变性行为还会影响数组对象是如何被复制与修改的,详细信息可参见集合类型的复制与拷贝行为

    注意: 在任何不需要改变集合大小的地方,最好将集合定义为不可变的。这么做能让Swift的编译器优化该集合的性能。

    转载:http://see.xidian.edu.cn/cpp/html/2292.html

    展开全文
  • 如果数组存放着大量图片,swift是值类型,将其拷贝,那内存不是吃力? OC 是直接告诉他内存地址 初学swift 如果打脸了,见谅
  • 数组字典、字符串都比oc省略了“@”数组var arr:Array = [1,2,3,4] //遍历数组 for number in arr { print(number) } //数组增加 arr.append(5) //数组的排序 let sortArr = arr.sort { (first, second) -> Bool ...

    数组、字典、字符串都比oc省略了“@”

    数组

    var arr:Array = [1,2,3,4]
    //遍历数组
    for number in arr
    {
        print(number)
    }
    //数组增加
    arr.append(5)
    //数组的排序
    let sortArr = arr.sort { (first, second) -> Bool in
        
        return first>second //(有大到小排序)
    }
    
    print(sortArr)
    
    //数组的删除
    arr.removeFirst()   //删除第一个
    arr.removeLast()    //删除最后一个
    arr.removeAtIndex(1) //删除索引为1的
    arr.removeAll()   //删除全部
    

    字典

    //创建字典
    var dict:Dictionary = ["name":"xiaoming","age":4]
    //获取value
    var nameStr = dict["name"]
    //遍历字典 会把key赋值第一个参数,value赋值第二参数
    for(key,value) in dict
    {
        print(key)
        print(value)
    }
    //增加key/value
    dict["gender"]="男"
    //更新key/value
    dict["age"] = 10
    //删除
    //dict.removeAll()  //删除全部
    dict.removeValueForKey("gender")
    
    //合并字典
    var dict2 = ["height":150]
    
    for(key,value) in dict2
    {
        dict[key] = value
    }
    

    字符串

    //字符串的初始化
    var str:String = "hellow Swift"
    
    var str2 = "222"
    
    //字符串的拼接和格式化
    str += str2
    let number = 100
    let name = "你刚回来了"
    //拼接其他类型
    var str3:String = "name = \(name),age = \(number)"
    //oc形式的拼接方法
    var str4 = String(format: "%@,%@", arguments: ["xiao","ming"])
    
    
    //字符串额截取(字符串和oc的字符串可以无缝连接)
    //装换oc的字符串可以使用oc的一些截取的方法
    var  str5:NSString = "你刚回来了"
    var  str6 = "你刚回来了" as NSString
    var substr = str6.substringWithRange(NSMakeRange(0, 4))
    
    //swift的字符的截取
    var str7 = "你刚回来了234567890"
    // let index = advance(s.startIndex, 5)  swift 1.x
    //let index2 = advance(s.endIndex, -6); swift 1.x
    let index = str7.startIndex.advancedBy(5) //swift 2.0+
    let index2 = str7.endIndex.advancedBy(-2) //swift 2.0+
    var range = Range<String.Index>(start: index,end: index2)
    //从什么地方开始截取(从index开始,不包含index的字符)
    var subStr1 = str7.substringFromIndex(index);
    //从0开始截取 到字符串中长度的减6的位置结束(不包含index2)
    var subStr2 = str7.substringToIndex(index2);
    //从index的位置到index2的位置(不包含index和index2的位置)
    var substr3 = str7.substringWithRange(range);
    
    //遍历字符
    for c in str4.characters
    {
        print(c)//从什么地方开始截取(从index开始,不包含index的字符)
    
    }
    
    展开全文
  • Swift数组字典

    2019-08-03 00:04:10
    Swift中的数组字典也有着一些让人眼前一亮的特性,今天的博客就来窥探一下Swift中的Array和Dictionary。还是沿袭之前的风格,在介绍Swift中的数组时,我们会对比一下ObjC中的数组字典,因为ObjC也是iOS开发的...

    http://www.cocoachina.com/swift/20151230/14802.html

     

    说到数组和字典,只要是编过程的小伙伴并不陌生。在Swift中的数组与字典也有着一些让人眼前一亮的特性,今天的博客就来窥探一下Swift中的Array和Dictionary。还是沿袭之前的风格,在介绍Swift中的数组时,我们会对比一下ObjC中的数组和字典,因为ObjC也是iOS开发的主要语言不是。无论是简单还是复杂的程序,数组和字典的用处还是比较多的,这两者虽然是Swift的基础内容,但是也不失其重要性。关于Objc的集合类请参考之前的博客《Objective-C中的集合类》。

    一、Swift中的数组(Array)

    数组在其他编程语言中都是存在的,数组就是一组数的集合。虽然其他编程语言中都有数组,但是不同语言中的数组都有着一些属于自己的特性。Swift也不例外,Swift中的数组使用起来还是比较人性化的.

    1.数组的声明与创建

    在聊Swift中的Array声明创建之前,我想聊一下ObjC中数组的声明与创建,下方是ObjC中不可变数组和可变数组的创建方式。在ObjC中可以使用NSArray来声明不可变数组,使用NSMutableArray来声明可变数组。

    1
    2
    3
    4
    NSArray *objcArray01 = [NSArray array];
         NSArray *objcArray02 = @[@(1), @(2)];
          
         NSMutableArray *mutableArray = [NSMutableArray array];

    而在Swift语言中,你可以使用关键字let来声明不可变数组,使用var来声明可变数组,下方代码声明的是Swift中的可变数组的几种方式。有一点需要注意的是ObjC中的数组只允许往里面存储对象,而不允许往里存储基本数据类型(Int, Float等)。而在Swift中是允许把基本数据类型存入数组中的,如下方代码段所示。下方给出了数组的三种定义的方式。后两种给数组元素制定了数据类型,表示该数组中只能够存储Int类型的值,如果你往里存入了其他的值,对不起,编译器会报错的。

    在Swift的数组中,如果在声明数组时没有指定数组中元素的数据类型,那么数组中是可以存放不同数据类型的数据的。如果你指定了数组中只允许存储一种数据类型,如果你再往里存储其他数据类型的话,那就是你的不对了,编译器回给你指出你的错误。具体如下所示:

     

    2.数组的操作

    (1)可变与不可变数组

    如果你想对数组中的元素进行增加、修改或者删除,那么你需要把Array定义成可变数组。如果你把数组定义成了不可变数组,但是你又对他进行了操作,那就是你的不对了。无论是ObjC还是Swift都不允许对不可变数组这位高冷的“御姐”动手动脚,不然会抛出一个错误的。但是可变数组就不一样了,你可以对可变数组进行增删改查操作。

    下图是在ObjC中对NSArray操作后的结果,你不能对NSArray中的元素进行修改,也就是说你对NSArray的操作权限只有读的权限,没有写的权限。如果你想对数组进行读写的权限的话,那你就有必要使用可变数组NSMutableArray了。使用NSMutableArray就不会报错,因为你对它有读写的权限。

    在Swift中的可变数组和不可变数组归根结底还是变量和常量也就是var和let关键字的使用了。你对变量持有读写的权限,对常量持有读的权限。下方的小实例,本质还是对let和var的讨论,下方是Swift实例:

      

    (2) 插入元素

    上面Swift实例中已经展示了如何往数组中插入元素。Swift中往数组中插入元素和OC中使用的方法是一样的,只是调用方法的方式不同。下方代码就是往可变数组arrayTest中的索引1的位置插入一个值“Objc”。语法比较简单就不做过多的赘述了。

    1
    arrayTest.insert("Objc", atIndex: 1);

     

    (3) 元素以及数组的追加

    你可以使用append函数来往数组的尾部追加值。如果你想把另一个数组追加到一个数组的后方,你可以使用+=运算符来操作。使用+=可以连接数组,这也是Swift中令人兴奋的一个特点。具体操作请看下方的实例:

     

    (4)移除元素

    上面是添加,接下来要搞一下移除元素。其实Swift中数组移除的方法名和用法和Objective-C中移除可变数组中的元素的方式极为相似。下方截图中是经常使用的移除方法,用法都没有什么难理解的地方,在此就简单的聊上一嘴。

    Void removeAll(): 移除数组中全部元素,有一个可选参数,keepCapacity。如果keepCapacity = YES的话,那么数组移除元素后,其存储空间还是存在的,在此往里存储值,不需再给他分配存储空间了。如果keepCapacity=NO的话,那么数组的存储空间就会被回收掉。

    String removeAtIndex(): 移除指定索引的元素,并且返回被移除的元素。

    String removeFrist(): 移除第一个元素,并返回被移除的元素。

    Void removeFirst(n: Int): 这个函数的意思是移除数组前方的几个元素,如果n = 1, 的话就移除前面一个元素这时与String removeFirst()函数功能相同。如果n = 3, 就移除前3个元素。

    String removeLast(): 移除数组中最后一个元素。

    Void removeRange(subRange: Range): 这个函数就比较全能呢,它可以移除数组中有效范围内的连续元素。它需要一个Range参数,下方是这个函数的使用方法,Range的起始位置是1,结束位置是2,就是移除索引1到2之间的元素。可以看Playground中的提示。 Range(start:1, end:2) 代表着半开区间1..<2。

     

    3. 使用Array构造函数给数组赋初始值

    在一些应用场景中我们需要为数组中的每一项进行初始化,也就是给数组的每一项赋上初始值。举个栗子~,比如我们要使用一个数组来记录公司每个季度的销售额,在数组初始化时,我们给给数组初始化4个初始值为零的元素。接下来就使用Array构造函数来做一些事情。下方就是在数组创建时给数组赋初始值。

     

    二、Swift中的字典(Dictionary)

    Swift中字典和Objective-C中的字典除了语法不一样外,用法也是大同小异的。字典中存放的就是Key和Value也就是键值对。可以通过Key来取出Value的值,在PHP这门强大的语言中,Array和Dictionary就是一个东西。其实数组就是一种特殊的字典,数组的key就是其下标,只不过这个下标不需要你去指定,由系统分配好,并且是元素在数组中是按下标从小到大排列的。在字典中的键值对是没有固定顺序的。

    1. 字典的创建

    在Swift中字典的创建和数组的创建也是类似的,就是比数组的item多了一个key。下方创建了两个字典,第一个字典是指定了key与value的数据类型,第二个字典没有为键值指定固定的数据类型。从Playground中我们容易的看出字典中的数据是没有固定数据的,因为读取字典中的值是通过key-value的形式而不是通过下标的方式。下方创建的都是可变字典,因为我们使用的是var关键字进行修饰的,如果你要创建不可变数组,我们就可以使用let关键字进行创建。关于let创建字典的内容,在此就不做过多的赘述了,因为只需要把下方的var换成let即可。

        

    2. 字典item的增删改查

    (1) 查询字典的值(读取)

    我们可以通过字典键值对的key来取出key对应的value。 下方的代码是分别取出“大毛”和“小黄”的值,如下所示:

    (2)字典的遍历

    只取一个值那多不爽呢,下面介绍一下字典的遍历方法。下方是遍历输出字典myDog中所有的key,字典的keys属性是获取字典中所有的key值。

    上述代码段输出结果如下,由输出结果可知,每个Value是可选类型的数据:

    1
    2
    3
           key: Optional("黄2")
            key: Optional("小黄")
            key: Optional("大黄")

    ===============================================================================

    上面是获取字典中的所有keys, 那么下面是获取字典中的所有values, 具体代码如下所示:

          上述代码段输出的结果值如下:

    1
    2
    3
             value:黄2
             value:小黄
             value:大黄

    ===============================================================================

    接下来就是对字典的整个item进行遍历,每个item遍历出来是一个元组。元组的内容是(key, value)。遍历出来的元组我们就可以通过使用元组的形式来获取字典的key和value。具体代码如下所示:

    输出结果如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    元组:(2, "黄2")
            key: 2
            value: 黄2
     
            元组:(3, "小黄")
            key: 3
            value: 小黄
     
            元组:(1, "大黄")
            key: 1
            value: 大黄

     

    (3) 字典的修改

    字典元素的修改是比较简单的,下方通过两种。第一种是通过key的形式直接给key对应的value赋值,不过这种修改方式是不会返回被修改的值的,具体代码如下:

    如果你想在修改值的时候返回被修改的原始值的话,你需要使用updateValue(forKey:)方法进行元素的修改。该函数是可以返回被修改的原始值的,具体实例如下所示:

     

    (4) 增加元素

    往已有的可变字典中增加元素就简单多了,直接通过key就可以给value赋值。在可变字典中,如果key已经存在,那么就变成上面的修改字典的值了。可以这么理解,通过key给value赋值时,如果key存在,就覆盖原有的键值对,如果不存在就添加。下方就是往字典中进行添加元素的语句:

     

    (5)移除元素

    下方截图中是所有字典移除元素的方法,

    removeAll():移除所有元素。

    removeAll(keepCapacity: Bool):移除所有元素, 如果keepCapacity为True,则保留字典原有的存储空间。

    removeValueForkey(key: Hashable): 这个方法是通过key来移除元素的。

    removeAtIndex(index: DictionaryIndex<hashable, value="">):这个是通过Dictionary的索引来删除元素的。但是字典的item是没有顺序的,那么我们怎么获取这个DictionaryIndex呢? 那么我们就会使用到另一个函数,就是indexForKey。具体用法如下,移除元素成功后会以元组的形式返回被删除的值。

     
     

    转载于:https://www.cnblogs.com/itlover2013/p/5095495.html

    展开全文
  • 3.8 Swift数组的遍历

    2016-12-13 14:24:59
    let array = [1, 3, 4, 5, "", 78, 9,10] as [Any]    for i in array {  print("元素=\(i)")  }   // EnumeratedSequence // 

      let array = [1, 3, 4, 5, "", 78, 9,10] as [Any]

            

            for i in array {

                print("元素=\(i)")

            }

            


    //        EnumeratedSequence

    //        'enumerate' is unavailable: call the 'enumerate()' method on the sequence

    //        for (index, value) in EnumeratedSequence(array)

    //        {

    //            // 这样子遍历,可以得到数组的值和下标

    //            print("index:\(index) = \(value)")

    //        }

            


            for (index, value) in array.enumerated()

            {

                // 这样子遍历,可以得到数组的值和下标

                print("index:\(index) = \(value)")

            }


    展开全文
  • Swift中的数组字典也有着一些让人眼前一亮的特性,今天的博客就来窥探一下Swift中的Array和Dictionary。还是沿袭之前的风格,在介绍Swift中的数组时,我们会对比一下ObjC中的数组字典,因为ObjC也是iOS开发的...
  • Swift数组扩容原理

    2019-02-27 02:17:44
    首先把结论写在文章开头,因为接下来的分析会有些啰嗦、复杂,如果不愿意深究的话只要记住Swift数组扩容的原理是: Swift2中创建一个空数组,默认容量为2,当长度和容量相等,且还需要再添加元素时,创建一个 ...
  • 上一篇博客向大家讲解了Swift中常量、变量和字符串,这篇再接着向大家介绍数组字典这两个在OC中使用十分频繁的数据类型在Swift中的一些基本的使用方法。
  • Swift提供了两种集合类型来存放多个值——数组(Array)和字典(Dictionary)。数组把相同类型的值存放在一个有序链表里。字典把相同类型的值存放在一个无序集合里,这些值可以通过唯一标识符(也就是键)来引用和查找。...
  • 数组字典、Slice操作 /* 1、数组 数组中可以存放不同类型数据 */ //Any关键字 :泛指数组中的各种数据类型 var arr1:Array = ["ming",12,2.3] print(arr1) /* 2、数组插入或者增加 */ print("\n2、数组插入...
  • Swift里,数组字典里所能存放的值的类型是明确的。这意味着你不能误把一个错误类型的值添加到数组字典里,也意味着你可以明白无误地知道从数组字典里取得的值会是什么类型的。Swift集合是类型明确的,这保证...
  • Swift数组使用

    2015-07-12 10:43:08
    Swift提供两种类型的集合,一种是数组Array,另外一种是字典Dictionary,他们之间的共同点是都是用来存储相同类型的数据,不同点是数组存放的数据是有序的,二字典存放的数据时无序的。字典还具有两外一个特性,...
  • 很多时候我们需要把从服务器端请求下来的数据转成model类,今天就介绍一下如何利用runtime实现字典转模型1、首先先建一个model类class Person:NSObject {  var name:String?  var age:NSNumber? } 2、为NSObject...
  • //Swift数组对它们能存放的值的类型是明确的。这不同于Objective-C的NSArray类和NSMutableArray类,Objective-C的数组能存储任何类型的对象 //Swift存储的数据类型要一致. var shoplist = ["eggs","milk"] ...
1 2 3 4 5 ... 20
收藏数 893
精华内容 357