Question

如果在swift中创建了两个数组：

var a:[CGFloat] = [1, 2, 3]
var b:[CGFloat] = [4, 5, 6]

如何将它们合并到[1, 2, 3, 4, 5, 6]？

Answer 1

您可以使用+连接数组，构建新数组

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]

Answer 2

使用Swift 5，根据您的需要，您可以选择以下六种之一来连接/合并两个数组。

＃1。使用`Array`＆＃39; s `+(_:_:)`泛型运算符

将两个数组合并为一个新数组

Array有一个+(_:_:)泛型运算符。 +(_:_:)具有以下declaration：

通过连接集合和序列的元素来创建新集合。

static func + <Other>(lhs: Array<Element>, rhs: Other) -> Array<Element> where Other : Sequence, Self.Element == Other.Element

以下Playground示例代码显示了如何使用[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` `+=(_:_:)`泛型运算符

将数组的元素追加到现有数组中

Array有一个+=(_:_:)泛型运算符。 +=(_:_:)具有以下declaration：

将序列的元素追加到范围可替换的集合中。

static func += <Other>(lhs: inout Array<Element>, rhs: Other) where Other : Sequence, Self.Element == Other.Element

以下Playground示例代码显示了如何使用[Int]泛型运算符将类型为+=(_:_:)的数组的元素附加到现有数组中：

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

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

＃3。使用`Array`＆n; `append(contentsOf:)`方法

将数组附加到另一个数组

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

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

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

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

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

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

＃4。使用`Sequence` `flatMap(_:)`方法将两个数组合并为一个新数组

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

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

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

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

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]

＃5。使用`Sequence`＆n; `joined()`方法和`Array` `init(_:)`初始化程序

将两个数组合并为一个新数组

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

返回序列序列的元素。

func joined() -> FlattenSequence<Self>

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

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

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

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

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]

＃6。使用`Array` `reduce(_:_:)`方法将两个数组合并为一个新数组

Swift Array有reduce(_:_:)方法。 reduce(_:_:)具有以下declaration：

返回使用给定闭包组合序列元素的结果。

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

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

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]

Answer 3

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

// 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]

Answer 4

自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())

Answer 5

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

var a = ["a", "b", "c"] 
var b = ["d", "e", "f"]

let res = [a, b].reduce([],combine:+)

所呈现的最佳替代方案（性能/内存方式）只是flatten，它只是懒惰地包装原始数组而不创建新的数组结构。

但请注意展平 不会返回 a LazyCollection，因此懒惰行为不会传播到沿着链的下一个操作（map，flatMap ，过滤等...）。

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

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

Answer 6

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

#include <fenv.h>
#include <stdio.h>

float hex2float (int hex_num) {
  return *(float*)&hex_num;
}

void main() {
  int a_int = 0x7f7fffff; // Maximum finite single precision number, about 3.4E38
  int b_int = 0x7f7fffff;
  float a = hex2float(a_int);
  float b = hex2float(b_int);
  float res_add;

  fesetround(FE_TOWARDZERO);  // need to include fenv.h for that
  printf("Calculating... %+e + %+e\n",a,b);
  res_add = a + b;
  printf("Res = %+e\n",res_add);
}

Answer 7

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]

这是上述代码的正确结果。

Answer 8

Swift 4.X

我知道的最简单的方法是只使用+号

var Array1 = ["Item 1", "Item 2"]
var Array2 = ["Thing 1", "Thing 2"]

var Array3 = Array1 + Array2

// Array 3 will just be them combined :)

Answer 9

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

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

连接/合并它们

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

Answer 10

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的所有元素。

谢谢。

Answer 11

不同数据类型的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]]

Answer 12

类似地，使用数组的字典可以：

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"]!)

您可以遍历dict1并添加dict2（如果“键”匹配）

Answer 13

Swift 5阵列扩展

extension Array where Element: Sequence {
    func join() -> Array<Element.Element> {
        return self.reduce([], +)
    }
}

示例：

let array = [[1,2,3], [4,5,6], [7,8,9]]
print(array.join())

//result: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Answer 14

所以这个问题真的很需要flatMap，不需要自己重新实现或者使用reduce：

var a:[CGFloat] = [1, 2, 3]
var b:[CGFloat] = [4, 5, 6]
let merged = [a, b].flatMap { $0 }

就是这样 - 玩得开心?

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

14 个答案:

＃1。使用`Array`＆＃39; s `+(_:_:)`泛型运算符

＃2。使用`Array` `+=(_:_:)`泛型运算符

＃3。使用`Array`＆n; `append(contentsOf:)`方法

＃4。使用`Sequence` `flatMap(_:)`方法将两个数组合并为一个新数组

＃5。使用`Sequence`＆n; `joined()`方法和`Array` `init(_:)`初始化程序

＃6。使用`Array` `reduce(_:_:)`方法将两个数组合并为一个新数组

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

14 个答案:

＃1。使用Array＆＃39; s +(_:_:)泛型运算符

＃2。使用Array +=(_:_:)泛型运算符

＃3。使用Array＆n; append(contentsOf:)方法

＃4。使用Sequence flatMap(_:)方法将两个数组合并为一个新数组

＃5。使用Sequence＆n; joined()方法和Array init(_:)初始化程序

＃6。使用Array reduce(_:_:)方法将两个数组合并为一个新数组

＃1。使用`Array`＆＃39; s `+(_:_:)`泛型运算符

＃2。使用`Array` `+=(_:_:)`泛型运算符

＃3。使用`Array`＆n; `append(contentsOf:)`方法

＃4。使用`Sequence` `flatMap(_:)`方法将两个数组合并为一个新数组

＃5。使用`Sequence`＆n; `joined()`方法和`Array` `init(_:)`初始化程序

＃6。使用`Array` `reduce(_:_:)`方法将两个数组合并为一个新数组