自Swift 2.0以来，我最喜欢的方法是扁平化

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

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

这将返回flatbidirectionalcollection，所以如果你只是想要一个CollectionType，这就足够了，你将有免费的懒惰求值。如果你确实需要数组，你可以这样做:

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

斯威夫特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 :)

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

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]

为了完成可能的选项列表，可以使用reduce来实现flatten的行为:

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

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

在这些方案中，最好的替代方案(性能/内存方面)是简单的扁平化，它只是惰性地包装原始数组，而不创建新的数组结构。

但是请注意flatten并不返回一个LazyCollection，因此懒惰行为不会沿着链传播到下一个操作(map、flatMap、filter等等)。

如果lazy在你的特定情况下是有意义的，只需要记住在flatten()前加上一个.lazy，例如，这样修改Tomasz sample:

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

斯威夫特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]

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

如果你想在一个特定的索引后面插入第二个数组，你可以这样做(从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]