• 测试数据准备: var publicParam = [ "method":"taobao.item.seller.get", "app_key":"12345678", "session":"test", "timestamp":"2016-01-...

    测试数据准备:

    var publicParam = [
                       "method":"taobao.item.seller.get",
                       "app_key":"12345678",
                       "session":"test",
                       "timestamp":"2016-01-01 12:00:00",
                       "format":"json",
                       "v":"2.0",
                       "sign_method":"md5"
                   ]
     let businessPara = [
               "fields":"num_iid,title,nick,price,num",
               "num_iid":"11223344"]
    

    通过 reversed() 可以拿到字典businessPara的key和value ,直接添加到publicParam即完成合并

     for (key,value) in businessPara.reversed() {
                publicParam[key] = value
            }
    

    打印合并之后的结果:

    print("- - - -- - - - - - - .合并之后")
         for (key,value) in publicParam.reversed() {
             print("key = \(key) value = \(value)")
         }
    

    打印结果:
    key = session value = test
    key = fields value = num_iid,title,nick,price,num
    key = app_key value = 12345678
    key = num_iid value = 11223344
    key = v value = 2.0
    key = sign_method value = md5
    key = format value = json
    key = timestamp value = 2016-01-01 12:00:00
    key = method value = taobao.item.seller.get

    使用sorted(by:)进行快速排序

    let after = publicParam.sorted { (arg0, arg1) -> Bool in
             if(arg0.key < arg1.key) {
                     return false
             }
             return true
         }
         print("- - - -- - - - - - - .排序之后")
         for (key,value) in after.reversed() {
             print("key = \(key) value = \(value)")
         }
    

    打印结果:
    key = app_key value = 12345678
    key = fields value = num_iid,title,nick,price,num
    key = format value = json
    key = method value = taobao.item.seller.get
    key = num_iid value = 11223344
    key = session value = test
    key = sign_method value = md5
    key = timestamp value = 2016-01-01 12:00:00
    key = v value = 2.0

    展开全文
  • 1.字典的定义通过 var /let 创建可变 和 不可变字典1.1创建一个空的字典var dic1 : Dictionary,Any> = [:]var dic2 : [String : Any] = [:];var dic3 = Dictionary,Int>()var dic4 = [String:Any]() 1.2创建一个不可...

    1.字典的定义

    通过 var /let 创建可变 和 不可变字典

    1.1创建一个空的字典

    var dic1 : Dictionary<String,Any> = [:]
    
    var dic2 : [String : Any] = [:];
    
    var dic3 = Dictionary<String,Int>()
    
    var dic4 = [String:Any]()
    

    1.2创建一个不可变字典

    Let person : Dictionary<String,Any> = [
                                "name":"老王",
                                "age":18,
                                "height":180
                                ]

    1.3创建一个可变字典

    var person : [String:Any] = [
                                  "name":"老王",
                                  "age":18,
                                  "height":180
                                  ]

    2.字典的增加 替换 删除 查询

    2.1 增加 替换

    var person : [String:Any] = [
                                  "name":"老王",
                                  "age":18,
                                  "height":180
                                  ]

    通过方法updateValue(value, forKey: key)进行替换或者添加
    如果 name 存在 更新对应的value,如果key
    不存在增加一个key 为name 的键值对

    1> person.updateValue("张三", forKey: "name")
    
    2> person["name"] = "张三"

    这里写图片描述

    1> person.updateValue("180", forKey: "weight")
    
    2> person["weight"] = "180"

    这里写图片描述

    2.2 删除

    通过指定的Key 删除

    person.removeValue(forKey: "age")

    这里写图片描述

    删除全部

    person.removeAll()

    2.2 查询

    查询所有的 key value

    for item in person.values {
        print(item)
    }

    这里写图片描述

    for item in person.keys {
        print(item)
    }

    这里写图片描述

    通过指定的Key 获取 value

       person["name"]

    这里写图片描述

    3.字典的遍历

    var stu : Dictionary<String,Any> = ["name":"小明","age":18]
    
    for (key,value) in stu {
        print("key:\(key) value:\(value)")
    }

    这里写图片描述

    4.字典的合并

    var dict : [String : Any] = ["name":"小明","age":18]
    let dict2 : [String : String] = ["title":"简历","name":"老王"]
    
    for (key,value) in dict2 {
        dict[key] = value
    }
    print(dict)
    

    这里写图片描述

    展开全文
  • Swift 字典

    2016-12-17 10:13:24
    字典字典的介绍字典允许按照某个键来访问元素 字典是由两部分集合构成的,一个是键(key)集合,一个是值(value)集合 键集合是不能有重复元素的,而值集合是可以重复的,键和值是成对出现的 Swift中的字典 Swift...

    字典

    字典的介绍

    字典允许按照某个键来访问元素
    字典是由两部分集合构成的,一个是键(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
    }
    
    展开全文
  • 自学swift3.0,如果有什么错误或建议的话欢迎吐槽哦~ //1.字典的定义使用[key:value,key:value]快速定义 let dic:[String:Any] = ["name":"张三","age":22] print(dic) //数组字典 let arrDic:[[String

    自学swift3.0,如果有什么错误或建议的话欢迎吐槽哦~

            //1.字典的定义使用[key:value,key:value]快速定义
            let dic:[String:Any] = ["name":"张三","age":22]
            print(dic)
            
            //数组字典
            let arrDic:[[String:Any]] = [
                ["name":"张三","age":22],
                ["name":"李四","age":24]
            ]
            print(arrDic)
            //2.可变字典的增删改查
            var dictionary:[String:Any] = ["name":"张三","age":22]
            print(dictionary)
            
            /*
             key存在则为修改,key不存在 则为添加
             */
            //增加键值对
            dictionary["score"] = 99
            print(dictionary)
            
            //修改键值对
            dictionary["age"] = 33
            print(dictionary)
            
            //删除键值对
            // ps: 字典是通过KEY来定位值的,所有的KEY必须是可以 hash/哈希 的 (md5就是一种哈希,哈希就是将字符串变成唯一的整数,便于查找,能够提高字典遍历的速度)
    //        dictionary.removeValue(forKey: <#T##Hashable#>)
            
            dictionary.removeValue(forKey: "score")
            print(dictionary)
            
            //字典遍历
            //写法一
            for e in dictionary {
                print("key = \(e.key)   value = \(e.value)")
                
            }
            
            //写法二
            for (key,value) in dictionary {
                print("key = \(key)   value = \(value)")
            }
            
            //字典合并
            var dic1 = ["name":"小明","score":"88"]
            print(dic1)
            let dic2 = ["teacher":"老大"]
            
            for (key,value) in dic2 {
                dic1[key] = value
            }
            print(dic1)
    



    展开全文
  • import UIKit /* 字典的介绍 1.字典允许按照某个键访问元素 2.字典是由两部分组成, 一... 4.Swift 字典类型是Dictionary 也是一个泛型集合 5.字典分为 可变字典和 不可变字典 let 修饰不可变字典 var修饰可变字典

    
    
    import UIKit
    
    /*
     字典的介绍
     1.字典允许按照某个键访问元素
     2.字典是由两部分组成, 一个键(key)集合, 一个是值(value)集合
     3.键集合是不能有重复的元素, 值集合可以有重复的元素, 键和值是成对出现的
     4.Swift 字典类型是Dictionary 也是一个泛型集合
     5.字典分为  可变字典和 不可变字典
     let 修饰不可变字典   var修饰可变字典
     */
    
    
    //1.定义字典
    //1>定义不可变字典
    //OC   @{@"name":@"summer",@"age":@18}
    //系统会自动判断后面[]中存放的键值对,还是一个一个元素
    let dict = ["name" : "summer", "age" : 18, "height" : 1.88] as [String : Any]
    
    //2>定义可变字典
    //var mutableDict = Dictionary<String, NSObject>() //方式一
    //AnyObject: 一般指定类型  NSObject: 一般用于创建对象
    //var mutableDict = [String : NSObject]()   //方式二
    var mutableDict = [String : AnyObject]() //常用  方式三
    
    //2.对可变字典的基本操作(增删改查)
    //2.1> 添加元素
    mutableDict["name"] = "summer" as AnyObject?
    mutableDict["age"] = 18 as AnyObject?
    mutableDict["height"] = 1.88 as AnyObject?
    mutableDict["weight"] = 60 as AnyObject?
    mutableDict
    //2.2> 删除元素
    mutableDict.removeValue(forKey: "age")
    mutableDict
    //2.3>修改元素
    //  区别:如果字典中已经有了对应的key, 那么会直接修改原来key中保存的value
    //  如果字典中没有对应的key, 那么添加对应的key/value
    mutableDict["name"] = "sun" as AnyObject?
    mutableDict
    mutableDict ["sex"] = "女" as AnyObject?
    mutableDict
    //2.4> 获取某一个元素
    mutableDict["sex"]
    
    //3.遍历字典
    //3.1>遍历字典中所有的key
    for key in mutableDict.keys{
        print(key)
    }
    //3.2>遍历字典中所以的值
    for value in mutableDict.values{
        print(value)
    }
    //3.3>遍历所有的键值对
    for (key, value) in mutableDict{
        print(key)
        print(value)
    }
    
    //4.字典的合并
    //即使类型一致也不能相加进行合并
    //let dict1 = ["name":"summer", "age" : 18] as [String : Any]
    //let dict2 = ["sex" : "男", "phoneNumber" : "+86 0393"] as [String : Any]
    //
    //let resultDict = dict1 + dict2  //写法是错误的
    
    //如果必须合并  那么只能
    var dict1 = ["name":"summer", "age" : 18] as [String : Any]
    let dict2 = ["sex" : "男", "phoneNumber" : "+86 0393"] as [String : Any]
    
    for (key, value) in dict2{
        dict1[key] = value as AnyObject?
    }
    dict1
    
    
    
    


    展开全文
  • swift 字典转模型框架

    2016-10-13 16:41:27
    swift 字典转模型框架
  • Swift Dictionary字典 简述 字典就是通过Key - Value对应关系的数据结构。 swift与OC字典区别 ​ 类型: Swift字典是值类型, OC字典类型为引用类型 初始化方法 你可以通过如下方式初始化字典。 // 创建一个空字典 ...
  • 数组和字典的创建和OC基本一致,不用写前面的@而已,但是遍历字典的时候,Swift由于有元祖这个东西在,改进的方便了一点,,举例如下: let dictionay = ["一":1,"二":2] //如果是OC的话,...
  • 持续更新中,纯笔记记录哦~ 相关的代码需要的话,还请留邮箱,后续我会更新到github上~~ ...而字典是无序的键值对数组集。 Swift的Array、Set和Dictionary类型被实现为泛型集合。因此,它所存储的元素的类
  • 字典 /// 定义并实例化字典 var dict = [String: AnyObject]() dict["name"] = "zhangsan" dict["age"] = 18 print(dict) // 设置相同 key,之前的数值会被覆盖 dict["name"] = "lisi" print(dict) // 删除某一...
  • 字典和数组的操作大致相同 , 只是在合并方面略有出入 //1.定义字典 (定义方法非常多 ,只写几种常用写法) //定义不可变字典 let dic = ["name":"my","age":18,"height":1.85] //定义可变字典 //创建一个值为任意...
  • swift字典

    2017-04-05 16:42:47
    //1.定义  func demo1(){  //OC中定义字典{} ... //Swift中同样使用[] // [KEY :VALUE] -> [String:NSObject]  let dict = ["name":"张","age":"18"]  print(dict)  //定义字典的数
  • 数组 Arrays 1、一个数组只能存储特定类型的数据; 2、所存储的数据不一定是一个类的对象,可以是基础数据类型; var array = [&amp;quot;A&amp;quot;,&amp;quot;B&amp;quot;...qu
  • 现有list: list1 = [{a: 123}, {a: 456},{b: ...合并成: list2 = [{a: [123,456]},{b: [789]}] from collections import defaultdict lst = [{'a': 123}, {'a': 456},{'b': 789}] dic = {} fo...
  • 字典是无序的键值对数组集。Swift的Array、Set和Dictionary类型被实现为泛型集合。因此,它所存储的元素的类型必须是一致的,同样,我们取出来的数据类型也是明确的。集合的可变性(Mutability Of Colle
  • Swift(07)- 字典

    2019-05-14 18:19:33
    字典 字典的介绍 字典允许按照某个键来访问元素 字典是由两部分集合构成的,一个是键(key)集合,一个是值(value)集合 键集合是不能有重复元素的,而值集合是可以重复的,键和值是成对出现的 Swift中的字典 ...
  • 数组 1、初始化一个空数组 我个人习惯于使用 Array.init() 初始化一个空字符串 2、初始化非空数组 并 遍历 PS :Any 表示数组中的元素可以是任意类型的元素 AnyObject表示对象类型,由于Str类型属于结构体类型,...
1 2 3 4 5 ... 20
收藏数 1,412
精华内容 564