Как объединить или объединить массивы в Swift?

Ответ 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]

Ответ 2

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

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

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. Добавить массив в другой массив с помощью метода Array append(contentsOf:)

Swift 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. Объединить два массива в новый массив с flatMap(_:) метода Sequence 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 joined() и init(_:) Array 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] в новый массив с помощью метода init(_:) 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. Объединить два массива в новый массив с помощью метода reduce(_:_:) Array reduce(_:_:)

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

Ответ 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]

Ответ 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())

Ответ 5

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

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

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

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

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

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

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

Ответ 6

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

Ответ 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]

это правильный результат приведенных выше кодов.

Ответ 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 :)

Ответ 9

Здесь самый короткий способ слияния двух массивов.

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

Объединить/объединить их

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

Ответ 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)

Приведенный выше код добавит все элементы arrayOne в конец arrayTwo.

Благодарю.

Ответ 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]]

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