Как объединить или объединить массивы в 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]

или добавить один массив к другому с помощью +=(или 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]

В Swift 5, в соответствии с вашими потребностями, вы можете выбрать один из шести следующих способов объединения / объединения двух массивов.

# 1. Объединить два массива в новый массив с Array«S +(_:_:)общего оператора

Arrayимеет +(_:_:)универсальный оператор. +(_:_:)имеет следующую декларацию :

Создает новую коллекцию путем объединения элементов коллекции и последовательности.

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имеет +=(_:_:)универсальный оператор. +=(_:_:)имеет следующую декларацию :

Добавляет элементы последовательности в коллекцию с возможностью замены диапазона.

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. Append массива в другой массив с Array«S append(contentsOf:)метода

У Свифта Arrayесть append(contentsOf:)метод. append(contentsOf:)имеет следующую декларацию :

Добавляет элементы последовательности или коллекции в конец этой коллекции.

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«S flatMap(_:)методом

Swift предоставляет flatMap(_:)метод для всех типов, которые соответствуют Sequenceпротоколу (включая Array). flatMap(_:)имеет следующую декларацию :

Возвращает массив, содержащий объединенные результаты вызова данного преобразования с каждым элементом этой последовательности.

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«S joined()методом и Array» s init(_:)инициализатор

Swift предоставляет joined()метод для всех типов, которые соответствуют Sequenceпротоколу (включая Array). joined()имеет следующую декларацию :

Возвращает элементы этой последовательности последовательностей, сцепленные.

func joined() -> FlattenSequence<Self>

Кроме того, у Swift Arrayесть init(_:)инициализатор. init(_:)имеет следующую декларацию :

Создает массив, содержащий элементы последовательности.

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«S reduce(_:_:)методом

У Свифта Arrayесть reduce(_:_:)метод. reduce(_:_:)имеет следующую декларацию :

Возвращает результат объединения элементов последовательности с использованием данного замыкания.

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]

Если вы не большой поклонник перегрузки операторов или просто более функционального типа:

// 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 сглаживается

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

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

Это вернется, FlattenBidirectionalCollectionтак что если вы просто хотите, CollectionTypeэтого будет достаточно, и вы будете иметь ленивую оценку бесплатно. Если вам нужен именно Array, вы можете сделать это:

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

Чтобы завершить список возможных альтернатив, reduceможно было бы использовать поведение flatten :

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

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

Лучшая альтернатива (с точки зрения производительности / памяти) среди представленных - просто flattenлениво оборачивать исходные массивы без создания новой структуры массива.

Но обратите внимание, что сглаживать не возвращается a LazyCollection, так что ленивое поведение не будет распространяться на следующую операцию по цепочке (map, flatMap, filter и т. Д.).

Если ленивости имеют смысл в вашем конкретном случае, только не забудьте добавить препенд или .lazyк flatten(), например, изменение Tomasz Sample следующим образом:

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

Если вы хотите, чтобы второй массив был вставлен после определенного индекса, вы можете сделать это (начиная с 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] 

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

Приведенный выше код добавит все элементы 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 :)

Вот кратчайший способ объединения двух массивов.

 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, если «ключ» совпадает

Массив 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]]