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

如果swift中创建了两个数组，如下所示：

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

---

如何将它们合并到

[1、2、3、4、5、6]

？

您可以将数组与

+

连接起来，构建一个新数组

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

或者使用

+=

将一个数组附加到另一个数组（或

附加

）：

---

如果您不太喜欢运算符重载，或者更喜欢函数类型：

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

---

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

这将返回

flattBidirectionalCollection

，因此，如果您只需要

CollectionType

，这就足够了，您将免费获得惰性评估。如果您确实需要阵列，可以执行以下操作：

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

---

要完成可能的备选方案列表，可以使用

reduce

实现展平行为：

在这些方法中，最好的选择（性能/内存方面）是简单的

展平

，它只是缓慢地包装原始阵列，而不创建新的阵列结构

但请注意，展平不会返回

LazyCollection

，因此惰性行为不会传播到链上的下一个操作（map、flatMap、filter等）

如果懒散在您的特定情况下有意义，只需记住在

展平（）

之前添加一个

.lazy

，例如，通过以下方式修改Tomasz示例：

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

---

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

let index=1
如果0。。。a、 计数=索引{
a[索引..使用Swift 5，根据您的需要，您可以选择以下六种方法之一来连接/合并两个数组

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


#1.使用
array
的
+（::）
通用运算符将两个数组合并为一个新数组
数组
有一个
+（::）
通用运算符。
+（::）
有以下内容：

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


#2.使用
array
的
+=（::）
通用运算符将数组的元素追加到现有数组中
数组
有一个
+=（:：）
通用运算符。
+=（：）
有以下内容：

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


#3.使用
array
的
Append（contentsOf:）
方法将一个数组附加到另一个数组中
Swift
Array
具有一个
append（contentsOf:）
方法。
append（contentsOf:）
具有以下功能：

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


#4.使用
Sequence
的
flatMap（:）
方法将两个数组合并成一个新数组
Swift为符合
顺序
协议（包括
数组
）的所有类型提供了
flatMap（:）
方法。
flatMap（:）
具有以下功能：

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


#5.使用
Sequence
的
joined（）
方法和
array
的
init（：）
初始值设定项将两个数组合并成一个新数组
Swift为符合
顺序
协议（包括
数组
）的所有类型提供了一种
joined（）
方法。
joined（）
具有以下功能：

返回此序列的元素，已连接

因此，下面的示例代码显示了如何使用
joined（）
方法和
init（quot:）
初始值设定项将两个
[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]

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

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

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

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]

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]

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

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]

这是上述代码的正确结果。
以下是合并两个数组的最短方法

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

连接/合并它们

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

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

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

如果希望结果为：[1,2,3，[4,5,6]]

arrayOne.append(arrayTwo)

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

如果您希望结果为：[1,2,3,4,5,6]，那么

arrayOne.append(contentsOf: arrayTwo)

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

谢谢。
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 :)

Swift 5阵列扩展

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

[任何对象]？与CGFloat不同。当连接到AnyObject数组时。Khunshan:
AnyObject
表示一个对象，据我所知，这意味着从类类型实例化的对象。
CGFloat
不是一个对象，而是一个标量值。据我所知，数组可以包含标量，除非定义为包含
AnyObject
或进一步细化。但是，我怀疑这里的问题是数组被包装在可选的文件中，因此您必须先用
！
或
打开它。
我们知道Swift 2的写时复制智能是否扩展到确定
a
的
b
部分是否被修改（因此，在
a.appendContentsOf（b）
期间，可能省略
b
的副本）？@OwenGodfrey谢谢。我对appendContentsOf和insertContentsOf有点困惑。谢谢分享这段代码，很好的解释，只是同意你的答案，如果你说哪一个性能更有效，那就最好了。我喜欢两个数组的
+
，一个数组的
joined（）
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result

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]

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

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

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]

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

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

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

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

arrayOne.append(arrayTwo)

arrayOne.append(contentsOf: arrayTwo)

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

var Array3 = Array1 + Array2

// Array 3 will just be them combined :)

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]