Ios 问题排序对象数组，不同对象但内容相同

我对一个对象数组进行排序时遇到了一个问题，这些对象是不同的，每个对象都有自己不同的objectId，但是有些对象的内容是相同的，这里是我的打印输出（Myarray）：对象类型notificationManager的数组

    [notificationManager, notificationManager, notificationManager,
    notificationManager, notificationManager, notificationManager, 
    notificationManager, notificationManager, notificationManager]

然而，我想对它们进行分组，因为在notificationManager中，我有一些属性，例如fromWho和forWho以及Activity，所以有一些notificationManager，它们有相同的属性fromWho，对于同一用户forWho和同一Activity，从逻辑上讲，它们是要重新组合的，我需要另一个数组来添加这样的唯一值，并跟踪每个元素出现的次数

    myArray[i].fromWho

因为对数组进行排序本身不会有任何区别，因为从外观上看，数组已经包含了不同的元素，对象的内容也不同，这是我的代码，但肯定需要做很多修改

    private static func removeDuplicates( origArray: [notificationManager]) -> [notificationManager?] {

     //initialize an empty array with the same count as the original    array
    var completionsToSend = [notificationManager?](repeating: nil, count: origArray.count)

   var j = 0


    for i in 0...origArray.count - 1 {
        let currentElemnt = origArray[i]

        if i < origArray.count - 1 {
        if (currentElemnt.fromwho.username != origArray[i+1].fromwho.username && currentElemnt.forwho.username != origArray[i+1].forwho.username && currentElemnt.activity != origArray[i+1].activity) {
            j += 1
            completionsToSend[j] = currentElemnt;
        }
        }
    }

if j < origArray.count - 1 {
    j += 1
completionsToSend[j] = origArray[origArray.count - 1]
}

    return completionsToSend
}

这也是我的notificationManager对象

class notificationManager: Hashable {
//MARK: Properties

var fromwho : PFUser!
var forwho : PFUser!
var type : Int!
var activity: ActivityModel!
var status : Int!
var date   : Date!
var transaction : paymentModel!
var participant : participantModel!
var hashValue: Int {
    return status.hashValue
}

init(fromwho: PFUser, forwho: PFUser, type: Int, activity: ActivityModel, status: Int, date: Date, transaction: paymentModel, participant: participantModel) {

    self.fromwho = fromwho
    self.forwho = forwho

    self.type = type

    self.activity = activity

    self.status = status

    self.date = date

    self.transaction = transaction

    self.participant = participant

}

//MARK: Inits
init(object:participantModel) {
    self.fromwho = object.participant
    self.forwho = object.activitymaker
    self.type = object.type
    self.activity = object.activity
    self.status = object.status
    self.date = object.updatedAt
    if object.transaction != nil{
         self.transaction = object.transaction
    }
    self.participant = object
}

---

有人能提出修改意见吗？谢谢

好的，根据who的

属性、who

和

活动的
过滤一个没有重复项的新数组

我创建了一个简单的模型来模拟您的问题，因为实现完全相同的情况有点困难，但是让我们深入研究一下

struct Item {  // as your Notification object
    var id: Int
    var name: String
    var nick: String
    var activity: Int
}
extension Item: Equatable {
    static func == (lhs: Item, rhs: Item) -> Bool {
     let name = lhs.name == rhs.name
     let activity = lhs.activity == rhs.activity
     let nick = lhs.nick == rhs.nick
     return name && activity && nick
    }
}
// sample  array of objects
let items: [Item] =  [
    Item(id: 1, name: "foo", nick: "foo", activity: 0),
 Item(id: 2, name: "foo", nick: "foo", activity: 0),
 Item(id: 3, name: "bee", nick: "bee", activity: 1),
 Item(id: 4, name: "boo", nick: "boo", activity: 2),
 Item(id: 5, name: "bee", nick: "bee", activity: 1),
 Item(id: 6, name: "cee", nick: "cee", activity: 3),
]

// filtration.
var newItems: [Item] = []
for item in items {
    if !newItems.contains(item){
        newItems.append(item)
    } else {
       print("alreadyExisted")
    }
}

正如您所看到的，我们只是确认了
equalable
协议，该协议允许我们在
=
操作符之间比较自定义对象或几乎任何东西

上面您可以看到，我使用它返回它的
Bool
值，基于
名称
，
尼克
，
活动
在每个
lhs
，
rhs
上是否彼此相等

这样，我就可以简单地在上面的
filtering
部分询问我的
array
是否包含
item
，因为它会根据这些属性检查该项是否已经存在

现在

对于您的情况，请确保按照上述
equalable
协议进行确认并执行检查

因为您基于的属性不是简单的
字符串
或
整数
因此，您可能还需要确认这些模型的
equalable
，这将为您提供一个如何实现的大图

在操场上测试代码

输出

已经存在2项

新数组[项目（id:1，名称：“foo”，尼克：“foo”，活动：0）

项目（id:3，名称：“蜜蜂”，尼克：“蜜蜂”，活动：1）

项目（id:4，名称：“boo”，尼克：“boo”，活动：2）

项目（编号：6，名称：“cee”，尼克：“cee”，活动：3）]

你能展示一下你的NotificationManager对象吗？是的，我确实修改了Post。它使用的唯一id是什么？实际上，我没有为每个forWho和fromWho元素的objectarray使用唯一id？它起作用了，我只是改变了一件事，我只比较了fromWho和forWho，它似乎也不比较活动，所以我不得不将其从公平扩展中删除
struct Item {  // as your Notification object
    var id: Int
    var name: String
    var nick: String
    var activity: Int
}
extension Item: Equatable {
    static func == (lhs: Item, rhs: Item) -> Bool {
     let name = lhs.name == rhs.name
     let activity = lhs.activity == rhs.activity
     let nick = lhs.nick == rhs.nick
     return name && activity && nick
    }
}
// sample  array of objects
let items: [Item] =  [
    Item(id: 1, name: "foo", nick: "foo", activity: 0),
 Item(id: 2, name: "foo", nick: "foo", activity: 0),
 Item(id: 3, name: "bee", nick: "bee", activity: 1),
 Item(id: 4, name: "boo", nick: "boo", activity: 2),
 Item(id: 5, name: "bee", nick: "bee", activity: 1),
 Item(id: 6, name: "cee", nick: "cee", activity: 3),
]

// filtration.
var newItems: [Item] = []
for item in items {
    if !newItems.contains(item){
        newItems.append(item)
    } else {
       print("alreadyExisted")
    }
}