如何在Swift中连接或合并数组？

11 回答

• 570

  同样，对于数组的字典，可以：

  var dict1 = [String:[Int]]()
  var dict2 = [String:[Int]]()
  dict1["key"] = [1,2,3]
  dict2["key"] = [4,5,6]
  dict1["key"] = dict1["key"]! + dict2["key"]!
  print(dict1["key"]!)
  

  如果“key”匹配，你可以迭代dict1并添加dict2

  回复于 2024-05-03T14:53:29+08:00
• 93

  如果您不是运算符重载的忠实粉丝，或者只是更多功能类型：

  // use flatMap
  let result = [
      ["merge", "me"], 
      ["We", "shall", "unite"],
      ["magic"]
  ].flatMap { $0 }
  // Output: ["merge", "me", "We", "shall", "unite", "magic"]
  
  // ... or reduce
  [[1],[2],[3]].reduce([], +)
  // Output: [1, 2, 3]
  

  回复于 2024-05-03T14:53:29+08:00
• 28

  如果你想在特定索引之后插入第二个数组，你可以这样做（从Swift 2.2开始）：

  let index = 1
  if 0 ... a.count ~= index {
       a[index..<index] = b[0..<b.count]
  }
  print(a) // [1.0, 4.0, 5.0, 6.0, 2.0, 3.0]
  

  回复于 2024-05-03T14:53:29+08:00
• 2

  这是合并两个数组的最短方法 .

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

  连接/合并它们

  array1 += array2
  New value of array1 is [1,2,3,4,5,6]
  

  回复于 2024-05-03T14:53:29+08:00
• 9

  var arrayOne = [1,2,3]
  var arrayTwo = [4,5,6]
  

  如果你想要结果为：[1,2,3，[4,5,6]]

  arrayOne.append(arrayTwo)
  

  上面的代码将arrayOne转换为单个元素，并将其添加到arrayTwo的末尾 .

  如果你想要结果为：[1,2,3,4,5,6]那么，

  arrayOne.append(contentsOf: arrayTwo)
  

  上面的代码将在arrayTwo的末尾添加arrayOne的所有元素 .

  谢谢 .

  回复于 2024-05-03T14:53:29+08:00
• 3

  自Swift 2.0以来我最喜欢的方法是flatten

  var a:[CGFloat] = [1, 2, 3]
  var b:[CGFloat] = [4, 5, 6]
  
  let c = [a, b].flatten()
  

  这将返回 FlattenBidirectionalCollection 所以，如果您只是想要一个 CollectionType 这就够了，您将免费进行懒惰评估 . 如果您需要完全相同的数组，您可以这样做：

  let c = Array([a, b].flatten())
  

  回复于 2024-05-03T14:53:29+08:00
• 19

  要完成可能的替代列表，可以使用 reduce 来实现展平的行为：

  var a = ["a", "b", "c"] 
  var b = ["d", "e", "f"]
  
  let res = [a, b].reduce([],combine:+)
  

  提供的最好的替代方案（性能/内存）就是 flatten ，它只是懒惰地包装原始数组而不创建新的数组结构 .

  但请注意将 does not return 变平 LazyColletion ，这样懒惰的行为就不会传播到沿着链的下一个操作（map，flatMap，filter等等） .

  如果懒惰在您的特定情况下有意义，请记住在 .lazy 之前添加或附加 .lazy ，例如，以这种方式修改Tomasz示例：

  let c = [a, b].lazy.flatten()
  

  回复于 2024-05-03T14:53:29+08:00
• 0

  Marge数组是不同的数据类型：

  var arrayInt = [Int]()
  arrayInt.append(6)
  var testArray = ["a",true,3,"b"] as [Any]
  testArray.append(someInt)
  

  输出：

  ["a", true, 3, "b", "hi", 3, [6]]
  

  回复于 2024-05-03T14:53:29+08:00
• 0

  您可以使用 + 连接数组，从而构建一个新数组

  let c = a + b
  print(c) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
  

  或使用 += （或 append ）将一个数组附加到另一个数组：

  a += b
  
  // Or:
  a.append(contentsOf: b)  // Swift 3
  a.appendContentsOf(b)    // Swift 2
  a.extend(b)              // Swift 1.2
  
  print(a) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
  

  回复于 2024-05-03T14:53:29+08:00
• 3

  使用Swift 3，根据您的需求和品味，您可以选择其中一个 five following ways 来连接/合并两个数组 .

  ---

  1.使用Swift标准库（： :)泛型运算符将两个数组合并为一个新数组

  Swift标准库定义了一个 +(_:_:) 泛型运算符 . +(_:_:) 具有以下declaration：

  func +<RRC1 : RangeReplaceableCollection, RRC2 : RangeReplaceableCollection where RRC1.Iterator.Element == RRC2.Iterator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1
  

  通过连接两个集合的元素来创建新集合 .

  以下Playground代码显示如何使用 +(_:_:) generic运算符将两个类型为 [Int] 的数组合并到一个新数组中：

  let array1 = [1, 2, 3]
  let array2 = [4, 5, 6]
  
  let flattenArray = array1 + array2
  print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
  

  ---

  2.使用Array的append（contentsOf :)方法将数组附加到另一个数组

  Swift Array 有一个 append(contentsOf:) 方法 . append(contentsOf:) 具有以下declaration：

  public mutating func append<S>(contentsOf newElements: S) where S : Sequence, S.Iterator.Element == Element)
  

  将序列或集合的元素添加到此集合的末尾 .

  以下Playground代码显示如何使用 append(contentsOf:) 方法将数组附加到另一个 [Int] 类型的数组：

  var array1 = [1, 2, 3]
  let array2 = [4, 5, 6]
  
  array1.append(contentsOf: array2)
  print(array1) // prints [1, 2, 3, 4, 5, 6]
  

  ---

  3.使用Sequence的flatMap（_ :)方法将两个数组合并到一个新数组中

  Swift为符合 Sequence 协议（包括 Array ）的所有类型提供 flatMap(_:) 方法 . flatMap(_:) 具有以下declaration：

  func flatMap<SegmentOfResult : Sequence>(_ transform: (Self.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
  

  返回一个数组，其中包含使用此序列的每个元素调用给定转换的连接结果 .

  以下Playground代码显示如何使用 flatMap(_:) 方法将两个 [Int] 类型的数组合并到一个新数组中：

  let array1 = [1, 2, 3]
  let array2 = [4, 5, 6]
  
  let flattenArray = [array1, array2].flatMap({ (element: [Int]) -> [Int] in
      return element
  })
  print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
  

  ---

  4.使用Sequence的joined（）方法和Array的init（_ :)初始化程序将两个数组合并为一个新数组

  Swift为符合 Sequence 协议（包括 Array ）的所有类型提供 joined() 方法 . joined() 具有以下declaration：

  func joined() -> FlattenSequence<Self>
  

  返回连接序列序列的元素 .

  此外，Swift Array 有一个 init(_:) 初始化程序 . init(_:) 具有以下declaration：

  init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
  

  创建一个包含序列元素的数组 .

  因此，以下Playground代码显示如何使用 joined() 方法和 init(_:) 初始化程序将两个类型为 [Int] 的数组合并到一个新数组中：

  let array1 = [1, 2, 3]
  let array2 = [4, 5, 6]
  
  let flattenCollection = [array1, array2].joined() // type: FlattenBidirectionalCollection<[Array<Int>]>
  let flattenArray = Array(flattenCollection)
  print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
  

  ---

  5.使用Array的reduce（： :)方法将两个数组合并到一个新数组中

  Swift Array 有一个 reduce(_:_:) 方法 . reduce(_:_:) 具有以下declaration：

  func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
  

  返回使用此序列的每个元素和累积值调用给定组合闭包的结果 .

  以下Playground代码显示如何使用 reduce(_:_:) 方法将两个类型为 [Int] 的数组合并到一个新数组中：

  let array1 = [1, 2, 3]
  let array2 = [4, 5, 6]
  
  let flattenArray = [array1, array2].reduce([], { (result: [Int], element: [Int]) -> [Int] in
      return result + element
  })
  print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
  

  回复于 2024-05-03T14:53:29+08:00
• 2

  Swift 3.0

  您可以通过使用加法运算符（ + ）将两个具有兼容类型的现有数组相加来创建新数组 . 新数组的类型是从您添加的两个数组的类型推断出来的，

  let arr0 = Array(repeating: 1, count: 3) // [1, 1, 1]
  let arr1 = Array(repeating: 2, count: 6)//[2, 2, 2, 2, 2, 2]
  let arr2 = arr0 + arr1 //[1, 1, 1, 2, 2, 2, 2, 2, 2]
  

  这是正确的结果以上代码 .

  回复于 2024-05-03T14:53:29+08:00