Question

我的表格视图中有2个部分。 Section 0具有来自数组的数据，section 1具有来自api的数据。现在，我要检查来自section 0的数据是否与section 1的数据匹配，然后我要从section 1删除该特定条目。不知道该怎么做...

我有2个数组，用于在每个部分填充数据：

filteredSelectedProductList  —> Section 0
productsList —> Section 1

这是我的代码：

      if self.filteredSelectedProductList.isEmpty == false {
        for prod in self.filteredSelectedProductList {  //section 0
          for filtProd in productsList {   //section 1
            if prod.productId == filtProd.productId {
              //Here I want to remove the matching entry from productsList array. How can I do that..?

            }
          }
        }
      }

Answer 1

您可以使用filter，而不能使用contains

类似的东西应该起作用，

var arr1 = [1,3,4,5,6] // array 1 section 0
var arr2 = [2,34,5,6] // array 2 section 1

print(arr2.filter{!arr1.contains($0)}) // [2,34]

在您使用自定义模型的情况下，您可以确认Equatable并对其进行以下操作，然后可以如我上面显示的那样简单地使用它。

struct MyCustomObject {
    var id: Int // some unique id you can compare things to
}

extension MyCustomObject: Equatable {
    static func == (lhs: MyCustomObject, rhs: MyCustomObject) -> Bool {
        return lhs.id  == rhs.id
    }
}

用法：

var arra1: [MyCustomObject] = [] // section 0 
var arra2: [MyCustomObject] = [] // section 1 
print(arra2.filter{!arra1.contains($0)})

Answer 2

Swift 4.1

您可以通过这种方式来做，您只需要放置数组而不是这个

var array1 = ["45","34","67"] //section 0
var array2 = ["45", "23"] // section 1

array2.removeAll(where: { array1.contains($0) }) // finalArray = ["23"]

Answer 3

您可以使用removeAll：

productsList.removeAll(where: { filteredSelectedProductList.contains($0) })

要使用包含，您的模型必须符合Equatable，否则您应该这样做：

productsList.removeAll(where: { item in filteredSelectedProductList.contains(where: { $0.productId == item.productId }) })

Answer 4

Array.contains是 O（ n ）操作。这意味着第一个数组中的每个元素，您可能必须搜索所有第二个数组。结果为 O（ m * n ），m和n是数组的计数，即没有效率。

更好的方法是：

构建第一个数组中元素出现的字典，
然后遍历第二个数组
在第二个数组中追加不属于第一个的元素。

这是一个执行上述步骤的函数，其时间复杂度为 O（ m + n ）：

func intersect<T: Hashable>(_ a1: [T], with a2: [T]) -> [T] {

    var result = [T]()
    result.reserveCapacity(a2.count)

    var dict1: [T: Int] = [T: Int].init(minimumCapacity: a1.count)

    for x in a1 {
        dict1[x, default: 0] += 1
    }

    for y in a2 {
        if dict1[y] == nil || dict1[y] == 0 {
            result.append(y)
        } else {
            dict1[y]! -= 1
        }
    }

    return result
}

请注意，数组的元素必须符合Hashable才能使用字典。 如果元素在第二个数组中出现的次数多于在第一个数组中的发生，则多余的重复项将被保留。其他所有答案都无法解决

以下是一些用例：

let array1 = [1, 2, 3, 4, 5, 6]
let array2 = [1, 2, 2, 4, 7, 6]

intersect(array1, with: array2) //[2, 7]

struct MyStruct: Hashable { var id: Int }

let array3 = [MyStruct(id: 0), MyStruct(id: 2), MyStruct(id: 3)]
let array4 = [MyStruct(id: 1), MyStruct(id: 2), MyStruct(id: 2)]

intersect(array3, with: array4)  //[{id 1}, {id 2}]

从数组中删除匹配的条目

4 个答案: