Question

我有一本字典例如：

let dict = Dictionary<Month, Array<Int32>>()

Obj1.price = "10"
Obj1.value = "abc"
Obj1.title = "January"

Obj2.price = "10"
Obj2.value = "def"
Obj2.title = "April"

Obj3.price = "10"
Obj3.value = "pqr"
Obj3.title = "February"

Obj4.price = "4"
Obj4.value = "mnq"
Obj4.title = "April"

dict = [ Obj1: [3,4], Obj2 : [1,2], Obj3: [8,9], Obj4: [3,3] ]

我有一个月份的自定义数组

let sortTemplate = ["April", "May", "June", "July", "August", "September", "October", "November", "December", "January", "February", "March"]

我希望将字典排序为 [Obj2：[1,2]，Obj4：[3,3]，Obj1：[3,4]，Obj3：[8,9]]

简而言之，我希望根据key属性上的自定义引用数组对字典进行排序。我知道我们不能排序字典，但想根据自定义sortTemplate排序并插入到字典数组中

这方面的任何暗示都是有用的。我知道我们可以使用值和键进行排序

Answer 1

这是一种使用Dictionary内置排序函数的可能解决方案，但是在示例中将title属性显示为自定义enum而不是String。然后，通过enum中的月份顺序隐式地给出“排序模板”。

即，enum MonthSortTemplate和你的班级MyClass（后者你没有把我们淋浴，所以我自己做了一个MWE）：

enum MonthSortTemplate: Int {
    case April = 1
    case January
    case February
    // ... rest of months follows, in the order you prefer
}

class MyClass {
    var price = ""
    var value = ""
    var title: MonthSortTemplate = .April    
}

// Hashable (just some dummy, don't know how you've set this up)
extension MyClass: Hashable {
    var hashValue: Int {
        return price.hashValue ^ value.hashValue
    }
}

// Equatable (just some dummy, don't know how you've set this up)
func ==(lhs: MyClass, rhs: MyClass) -> Bool {
    return lhs.price == rhs.price && lhs.value == rhs.value
}

创建MyClass实例，添加到词典中，并使用后者的.sort(...)函数进行自定义闭包，为此特定类型的比较指定。

var Obj1 = MyClass()
var Obj2 = MyClass()
var Obj3 = MyClass()

Obj1.price = "10"
Obj1.value = "abc"
Obj1.title = .January

Obj2.price = "10"
Obj2.value = "def"
Obj2.title = .April

Obj3.price = "10"
Obj3.value = "pqr"
Obj3.title = .February

var dict = Dictionary<MyClass, Array<Int32>>()
dict = [ Obj1: [3,4], Obj2 : [1,2], Obj3: [8,9]]

// your custom sort closure, for Dictionary.sort(...) method
let byMonthTemplate = {
    (elem1:(key: MyClass, val: [Int32]), elem2:(key: MyClass, val: [Int32]))->Bool in
    if elem1.key.title.rawValue < elem2.key.title.rawValue {
        return true
    } else {
        return false
    }
}

let sortedDict = dict.sort(byMonthTemplate)
print("\(dict)")

另一种选择 - 如果你真的喜欢你的类属性title属于String类型---是为<个对象定义MyClass运算符：

func <(lhs: MyClass, rhs: MyClass) -> Bool {
    // do comparison stuff with strings lhs.title and rhs.title
    // with regard to your ordering of choice (array sortTemplate)
    return ... 
}

在这种情况下，“杂乱”的东西最终会出现在这个函数中，而实际的排序可以非常优雅地执行

let sortedDict = dict.sort { $0.0 < $1.0 }

就个人而言，我更喜欢enum解决方案（但是，这不是主题）。

编辑：

根据您的要求，我将为您的班级<添加一个MyClass运算符示例。这绝不是最佳的，但也许你可以从我的例子中改进它。

// add sortTemplate as a static property of MyClass
class MyClass {
    var price = ""
    var value = ""
    var title = "" 
    static let sortTemplate = ["April", "May", "June", "July", "August", "September", "October", "November", "December", "January", "February", "March"]
}

// define < operator for MyClass objects
func <(lhs: MyClass, rhs: MyClass) -> Bool {
    let indexOfLhs = MyClass.sortTemplate.indexOf({$0 == lhs.title})
    let indexOfRhs = MyClass.sortTemplate.indexOf({$0 == rhs.title})
    return indexOfLhs < indexOfRhs
}

// you can now sort your dictionary according to
let sortedDict = dict.sort { $0.0 < $1.0 }

Answer 2

希望这种帮助，快速而肮脏的方式

let dict = ["Obj1":[3,4],"Obj2":[1,2],"Obj3":[8,9],"Obj4":[3,3]]

let dict1 =  dict.sort { $0.1[0] < $1.1[0]} //Sort by first object in array
let dict2 =  dict1.sort { $0.1[1] < $1.1[1]} //Sort by second object in array

print(dict2)

输出：[("Obj2", [1, 2]), ("Obj4", [3, 3]), ("Obj1", [3, 4]), ("Obj3", [8, 9])]

按键中对象的属性对字典进行排序/过滤

2 个答案: