4字典类型 swift_swift 4 字典类型转jsonobject - CSDN
  • Swift初见】Swift字典

    2015-02-27 19:33:24
    顾名思义,当我们查字典的时候,我们会根据索引去查找我们需要查找的资源,在swift中也是如此,字典的每一个对象都包含一个key和一个value,我们通过key去查找当前这个key所对应的value,与数组不同的是字典中的数据...

    顾名思义,当我们查字典的时候,我们会根据索引去查找我们需要查找的资源,在swift中也是如此,字典的每一个对象都包含一个key和一个value,我们通过key去查找当前这个key所对应的value,与数组不同的是字典中的数据项在字典中没有具体的存储顺序。

    和Swift中数组类似的,在Swift可变字典与不可变字典仅仅通过let和var的定义来区分,而在OC中是通过NSDictionary和NSMutableDictionary来区分的。

    Swift的字典定义为:(key: value),对于key和value是有限制的,key的唯一限制是可hash的,这样就能保证key是独一无二的,key的address就为:addr = hash(key) , value = hashTavle[addr],先获取到key的地址,然后在哈希表中通过找到的key的地址来找到value的值。


    字典的构造:
    与数组类似的,字典也有很多相似的语法:
    var dict = ["key1":"value1" , "key2":"value2"]
    println(dict)

    输出为:[key1: value1, key2: value2]
    我们知道swift具有类型推导的功能,我们不用定义key和value的类型,OS就能帮我们推导出key和value都是String类型。

    我们也可以在申明一个字典的时候定义好字典中key和value的类型。
    var dict2 : Dictionary<String, Int> = ["key1":1, "key2":2]
    println(dict2)

    输出为:[key1: 1, key2: 2]

    当然我们也有一种省略一点的定义方式:
    var dict3 : [String : Int] = ["key3": 3, "key4":4]
    println(dict3)

    输出为:[key4: 4, key3: 3]

    我们也可以像数组一样使用构造语句来创建一个空字典:
    var emptyDict = Dictionary<String, String>()

    此时我们就创建了一个key和value都是字符串的空字典;
    如果我们在创建字典的时候不知道要放什么类型的数据,我们也可以利用swift的类型推导功能在以后添加数据项的时候自动推导:
    var emptyDict2 = [ : ]


    数组的操作:
    对数据的基础操作包含增删改查,对字典的操作同样如此:
    对字典新增一项时,我们可以通过下标来添加新的数据项,比如对dict添加一项:
    dict["key3"] = "value3"
    println(dict)

    此时dict中有三项了,输出为:[key1: value1, key3: value3, key2: value2]

    修改字典中某一项的值时也可以用下标来进行操作:
    dict["key1"] = "NOValue"
    println(dict)

    此时的输出就为:[key1: NOValue, key3: value3, key2: value2]
    swift还提供了一个updateValue的方法来更新字典中的值,
    dict.updateValue("123", forKey: "key4")
    println(dict)

    如果key存在则更新key所对应的value,如果key不存在则新增一条记录。

    和数组一样,我们可以通过字典的只读熟悉count来获取字典中的数据项的数量。

    如果我们需要从一个字典中移除某个数据项,有这么2种方式:
    1、用下标的方式来给某个键的对应值赋值为nil,这个该数据项就从字典中移除了:
    dict["key4"] = nil
    println(dict)

    从输出中我们可以明显的看出key4所对应的数据项已经从字典中移除掉了;
    2、用swift提供的函数:removeValueForKey:
    dict.removeValueForKey("key1")
    println(dict)

    3、用removeAll方式来移除所有数据项。


    字典遍历
    还记得在数组的遍历中有2种方式,一种是for-in循环来遍历,一种是enumerate来遍历数据项和索引返回一个元祖,在字典的遍历中有下面几种方式:
    1、for-in循环:
    var dict = ["key1" : "value1" , "key2" : "value2" , "key3" : "value3"]
    
    for key in dict{
        println(key)
    }
    
    for (key,value) in dict{
        println("key is \(key) and value is \(value)")
    }
    
    for (key, _) in dict {
        println(key)
    }
    
    for (_, value) in dict {
        println(value)
    }


    输出为:

    (key1, value1)
    (key3, value3)
    (key2, value2)
    key is key1 and value is value1
    key is key3 and value is value3
    key is key2 and value is value2
    key1
    key3
    key2
    value1
    value3
    value2


    我们看到这几种方式,第一种直接打印出键值对的值,第二种我们的条件里面写了一个元组,分别打印key和value,第三种我们加了一个下划线,表示我们不关心第二项value的值,我们只要第一项,第四种方式即我们只关心value的值:


    2、我们可以通过字典的keys熟悉来返回当前字典的所有的key,同样可以返回字典的所有value,
    for keys in dict.keys {
        println(keys)
    }
    
    for values in dict.values {
        println(values)
    }

    字典的keys和values返回的是一个集合,我们可以直接使用keys或者values属性来构造一个新数组:
    let keysArray = Array(dict.keys)
    println(keysArray)

    字典中的数据项是无序排列的,当我们遍历字典的时候,key和value会重新排列,而且其中的顺序是不固定的。



    欢迎大家指导,共同学习。





    展开全文
  • Swift 字典

    2016-12-17 10:13:24
    字典字典的介绍字典允许按照某个键来访问元素 ...Swift字典类型是Dictionary,也是一个泛型集合 字典的初始化 Swift中的可变和不可变字典 使用let修饰的数组是不可变字典 使用var修饰的数组是可变字典 // 定义一个可变

    字典

    字典的介绍

    字典允许按照某个键来访问元素
    字典是由两部分集合构成的,一个是键(key)集合,一个是值(value)集合
    键集合是不能有重复元素的,而值集合是可以重复的,键和值是成对出现的
    Swift中的字典
    Swift字典类型是Dictionary,也是一个泛型集合
    

    字典的初始化

    • Swift中的可变和不可变字典
    • 使用let修饰的数组是不可变字典
    • 使用var修饰的数组是可变字典
      // 定义一个可变字典
      var dict1 : [String : NSObject] = String : NSObject

      // 定义一个不可变字典
      let dict2 = [“name” : “why”, “age” : 18]
      在声明一个Dictionary类型的时候可以使用下面的语句之一
      var dict1: Dictionary

    字典的基本操作

    // 添加数据
     dict["height"] = 1.88
     dict["weight"] = 70.0
     dict
    
    // 删除字段
    dict.removeValueForKey("height")
    dict
    
    // 修改字典
    dict["name"] = "lmj"
    dict
    
    // 查询字典
    dict["name"]
    

    字典的遍历

    // 遍历字典中所有的值
    for value in dict.values {
    print(value)
    }
    // 遍历字典中所有的键
    for key in dict.keys {
    print(key)
    }
    
    // 遍历所有的键值对
    for (key, value) in dict {
    print(key)
    print(value)
     }
    

    字典的合并

    // 字典的合并
    var dict1 = ["name" : "yz", "age" : 20]
    var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
    // 字典不可以相加合并
    for (key, value) in dict1 {
    dict2[key] = value
    }
    
    展开全文
  •  字典也是一种集合数据类型  和数组不太一样,哪点不太一样呢  数组中的元素是连续存储的  字典里面的元素是没有顺序的  字典如何检索呢,字典存储键值对  里面的每一个 key 唯一的, 

      /**

             字典的基本概念

             

             字典也是一种集合数据类型

             和数组不太一样,哪点不太一样呢

             数组中的元素是连续存储的

             字典里面的元素是没有顺序的

             字典如何检索呢,字典存储键值对

             里面的每一个 key 唯一的,  值可以有相同的

             

             

             哈希函数

             address = hash(key), value =  hashTable[address]

             

             通过哈希函数计算出地址来定位 value

             为什么通过哈希函数来做呢,查找效率高啊

             所以字典的背后机制呢,是基于哈希的

             */

            

    //        var dic = [key1:value1, key2:value2, key3:value3, ...]

            

            // 空数组 swift3.0 中不可以再这样子直接 赋空

    //        let arr = []


            let arr = NSArray()

            print(arr)

            print("-------------->")


            

            

            // 空字典 swift3.0 中不可以再这样子直接 赋空

    //        let dic = [:]

            let dic = NSDictionary()

            print(dic)

            print("-------------->")


            

            /**

             key 关键字一定是可hash

             String/Int/Float/Bool 等都可以

             */

            let dic1 = [1 : "1", 2 : "2"]

            


            

            print(dic1)

            print("-------------->")

            

            let dic2 = ["1":1, "2":"2", 3:"3"] as [AnyHashable : Any]

            print("-------------->")

            print(dic2)


            // 定义了特定类型的键值对

            let dic3: Dictionary<String, Int> = ["3" : 4]

            print("-------------->")

            print(dic3)


            // 也可以这样子定义啊

            let dic4: [String : Int] = ["3" : 4]

            print("-------------->")

            print(dic4)


            

            print("-------------->")

            print(dic4.count)

    展开全文
  • Swift 字典用来存储无序的相同类型数据的集合,Swift 字典会强制检测元素的类型,如果类型不同则会报错。 Swift 字典每个值(value)都关联唯一的键(key),键作为字典中的这个值数据的标识符。 和数组中的数据项...

    Swift 字典用来存储无序的相同类型数据的集合,Swift字典会强制检测元素的类型,如果类型不同则会报错。

    Swift字典每个值(value)都关联唯一的键(key),键作为字典中的这个值数据的标识符。

    和数组中的数据项不同,字典中的数据项并没有具体顺序。我们在需要通过标识符(键)访问数据的时候使用字典,这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

    Swift字典的key没有类型限制可以是整型或字符串,但必须是唯一的。

    如果创建一个字典,并赋值给一个变量,则创建的字典就是可以修改的。这意味着在创建字典后,可以通过添加、删除、修改的方式改变字典里的项目。如果将一个字典赋值给常量,字典就不可修改,并且字典的大小和内容都不可以修改。


    // 创建字典
    // 创建一个特定类型的空字典,格式为:var dict = [KeyType: ValueType]()
    // 创建一个空字典,键的类型为 Int,值的类型为 String 的简单语法:
    var dict01 = [Int: String]()
    print(dict01)
            
    // 创建一个字典的实例:
    var dict02 :[Int:String] = [1:"One", 2:"Two", 3:"Three"]
    print(dict02)
            
    var dict03 = ["name":"DevZhang", "job":"iOSDev", "company":"VSTECS"]
    print(dict03)
    // 访问字典
    // 我们可以根据字典的索引来访问数组的元素,语法如下:var value = dict[key]
    let value01 = dict02[1]
    print(value01)
            
    let value02 = dict03["name"]
    print(value02)
    // 添加数据
    let value03 = dict02.updateValue("Four", forKey: 4)  //或 dict02[4] = "Four"
    print(value03)
    print(dict02)
    // 修改字典
    // 方法1 使用 updateValue(forKey:) 增加或更新字典的内容。如果 key 不存在,则添加值,如果存在则修改 key 对应的值。格式为:dict.updateValue(value, forKey:key)方法返回Optional值。
    var value04 = dict02.updateValue("TwoTmp", forKey: 2)
    print(dict02)
    print(value04)
     
    // 方法2 通过指定的 key 来修改字典的值
    var value05 = dict02[3]
    print(value05)
    value05 = "ThreeTmp" // 修改无效
    print(dict02)
    dict02[3] = "ThreeTmp" // 修改有效
    print(dict02)
    
    // 移除 Key-Value 对
    // 1 使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值,如果不存在返回 nil 。
    let valueRemove01 = dict02.removeValueForKey(2)
    print(valueRemove01)
    print(dict02)
            
    // 2 通过指定键的值为 nil 来移除 key-value(键-值)对。
    dict02[1] = nil
    print(dict02)
    // 遍历字典
    // 1 使用 for-in 循环来遍历某个字典中的键值对。
    for (key, value) in dict03
    {
     print("字典 key \(key) -  字典 value \(value)")
    }
            
    // 2 使用enumerate()方法来进行字典遍历,返回的是字典的索引及 (key, value) 对
    for (key, value) in dict03.enumerate()
    {
     print("字典 key \(key) -  字典 (key, value) 对 \(value)")
    }
    
    // 3 
    for key in dict03.keys
    {
     let value = dict03[key]
     print("key = \(key), value = \(value)")
    }
    
    // 字典转换为数组
    // 提取字典的键值(key-value)对,并转换为独立的数组。
    let dictKeys = [String](dict03.keys)
    for (key) in dictKeys
    {
     print("\(key)")
    }
            
    let dictValues = [String](dict03.values)
    for (value) in dictValues
    {
     print("\(value)")
    }
    // count 属性
    let count01 = dict03.count
    print(count01)
    // isEmpty 属性
    let empty01 = dict01.isEmpty
    print("dict01 is \(empty01)")
            
    let empty02 = dict03.isEmpty
    print("dict03 is \(empty02)")











    展开全文
  • Swift语言提供了经典的数组和字典两种集合类型来存储数据。数组用来按顺序存储相同的类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址(就是键值对)。 Swift语言里的数组和字典中存储...

           Swift语言提供了经典的数组和字典两种集合类型来存储数据。数组用来按顺序存储相同的类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址(就是键值对)。

            Swift语言里的数组和字典中存储的数据值类型必须明确。这意味着我们不能把不同正确的数据类型插入其中。同时这也说明我们完全可以对获取出的值类型非常自信。Swift对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚。也让我们在开发中可以早早地找到任何的类型 不匹配错误。

            Swift的字典使用时需要具体规定可以存储键和值类型。不同于objective-C 的NSDictionary 和 NSMutableDictionary 类可以使用任何类型的对象来作为键 和 值并且不提供任何关于这些对象本质的信息。在Swift中,在某个预定的字典中可以存储的键 和 值必须提前定义清楚,方法是通过显性类型标注或者类型推断。

           清楚了字典的特性后就方便我们正确的使用。在实际开发中发现对字典排序的需求非常多,于是结合网上资料整理出如下代码以供大家参考:

    按照键排序:

       let dicGradeData:[Int:Array] = [1:["三班","四班","一班","二班"],6:["一班","二班","三班"],5:["一班","三班","二班"],2:["四班","一班","二班","三班"],3:["一班","二班","三班","四班"],4:["一班","三班","四班","二班"]]
       NSLog("排序前:%@",dicGradeData)
    
       //按照键降序排序
       var arrTemp = dicGradeData.sort { (t1, t2) -> Bool in
           return t1.0 > t2.0 ? true:false
       }
       print("按照键降序排序:")
       for (key,value) in arrTemp{
           print(key,value)
       }
    
       //按照键升序排序
       arrTemp = dicGradeData.sort({ (t1, t2) -> Bool in
            return t1.0 < t2.0 ? true:false
       })
       print("按照键升序排序:")
       for (k,v) in arrTemp{
           print(k,v)
       }
    

    按照值排序:

       var arrDicData:[[String:NSObject]] = [[String:NSObject]]()
       for i in 0..<10 {
           arrDicData.append([
                "ID": i,
                "Age": 18 + (Int)(arc4random() % 100),
                "Name":"test\(i + 1)",
                "Sex":i % 2 == 0 ? "Man":"Woman",
                "AddDatetime":(Int)(NSDate().timeIntervalSince1970)
           ])
       }
       NSLog("按照字典值排序前:%@",arrDicData)
    
       let ageDesc:[[String:NSObject]] = arrDicData.sort { (t1, t2) -> Bool in
           return (t1["Age"] as! Int) > (t2["Age"] as! Int) ? true:false
       }
       NSLog("按照年龄值降序排序后:%@",ageDesc)
       
                    (注:按照值升序排序做法同上,此处省略300行……)
    


    本文只是抛砖引玉,如有纰漏请见谅!
    关于Swift字典的其他基本用法请自行查找资料,可参考本网址:https://www.gitbook.com/book/numbbbbb/-the-swift-programming-language-/details


    展开全文
  • 数组和字典的创建和OC基本一致,不用写前面的@而已,但是遍历字典的时候,Swift由于有元祖这个东西在,改进的方便了一点,,举例如下: let dictionay = ["一":1,"二":2] //如果是OC的话,...
  • import UIKit /* 字典的介绍 1.字典允许按照某个键访问元素 2.... 3.... 4.Swift 字典类型是Dictionary 也是一个泛型集合 5.字典分为 可变字典和 不可变字典 let 修饰不可变字典 var修饰可变字典
  • Swift3字典编辑

    2017-05-03 19:04:43
    以一个合适类型的新键作为下标索引,并且赋给它一个合适类型的值,就可以对字典增加一个新的键-值对元素。  1 | var addressDict = ["上海" : "黄浦区","广东" : "深圳","江苏" : "南京"]  2 |
  • //字典时集合类型 存放多个键值对 //字典中键是唯一的 不能重复 //字典中存放的键值对是无序的写入的顺序于读出的顺序可能不同 //字典中存放的数据可以是任意类型的 //字典分为可变于不可变来那个两种 // 创建空字典...
  • //: Playground - noun: a place ...//字典也叫map 映射 //声明个空的字典 var Dict0 = Dictionary&lt;Character, Any&gt;() Dict0.isEmpty //true   //可以直接给字典添加一个key和一个value Dict0...
  • Swift 中实现字典

    2017-02-04 10:14:10
    虽然 Swift 原生的字典类型实现的 很复杂 (毫无疑问是为了性能),但是我们可以利用 Swift 提供的工具写出漂亮简洁的实现。我们从一个简单的实现开始,并且逐步添加功能。 我们简要看一下字典的工作原理:它...
  • 如果数组存放着大量图片,swift是值类型,将其拷贝,那内存不是吃力? OC 是直接告诉他内存地址 初学swift 如果打脸了,见谅
  • Swift 字典转数组

    2019-01-15 11:51:02
    1.Swift 类型字典(Dictionary) let dic = ["name":"Tom","gender":"male","address":"XXXX省XXX市","age":76] as [String : Any] ...
  • 写在前面的话现在很多iOS项目的开发开始转向Swift语言。 相信 Swift语言很快会成为iOS工程师 必备技能。 字典转模型, 模型转转字典在开发过程中扮演非常重要的角色。 今天就和大家分享一下使用Swift,如何进行字典...
  • Swift - 字典 (Dictionary)

    2019-01-13 13:27:45
    目前 Swift 的 Dictionary 类型被桥接到 Foundation 的 NSDictionary 类; 一个字典的 Key 类型必须遵循 Hashable 协议,就像 Set 的值类型; 创建 // 1. 创建一个可变的空字典 var dictName = [In...
  • //创建字典的方法 var someDict = [Int:String]() someDict.count //定义一个key为字符串value也为字符串的字典 //这种的之所以没有按照顺序排列 因为不是数字的,是字符串的排列方式 var someDict1 : [String:...
  • /* Swift 提供了两种集合类型,即数组(Array)和字典(Dictionary),存储值的集合 数组存储相同类型的顺序列表值。字典存储无序同类型值的集合,通过键来查询和 引用。 在Swift中,数组和字典总是值和键的存储类型是...
  • 写了一段小代码,总结了一下关于Swift集合类之数组和数据字典相关的使用方法。 // 集合类型:数组和数据字典类型保持一致)  // 数组  //1、 定义空数组和创建非空数组  var arr:[String] = [String]() ...
  • Swift 字典的常用方法

    2015-08-14 17:25:12
    /* * *要正确使用字典,也需要一些条件 * 1,字典键值对的 键和值的类型必须明确,可以直接指定,也可以类似数组直接赋值由编译器自动识别 * 2,字典必须要初始化 ...var dic1=[1:1,2:12,3:32,4:16,5:15] var
1 2 3 4 5 ... 20
收藏数 7,859
精华内容 3,143
关键字:

4字典类型 swift