How do I concatenate or merge arrays in Swift?

merge two arrays without duplicates swift
swift merge arrays unique
swift array
swift combine two arrays into dictionary
swift merge dictionaries
swift join array
swift append all array
swift flatten array

If there are two arrays created in swift like this:

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

How can they be merged to [1, 2, 3, 4, 5, 6]?


You can concatenate the arrays with +, building a new array

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

or append one array to the other with += (or 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]

How do I concatenate or merge arrays in Swift?, How do you add an element from one array to another array? 4. Merge two arrays into a new array with Sequence‘s joined() method and Array‘s init(_:) initializer. Swift provides a joined() method for all types that conform to Sequence protocol (including Array). joined() has the following declaration: func joined() -> FlattenSequence<Self> Returns the elements of this sequence of sequences, concatenated.


With Swift 5, according to your needs, you may choose one of the six following ways to concatenate/merge two arrays.


#1. Merge two arrays into a new array with Array's +(_:_:) generic operator

Array has a +(_:_:) generic operator. +(_:_:) has the following declaration:

Creates a new collection by concatenating the elements of a collection and a sequence.

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

The following Playground sample code shows how to merge two arrays of type [Int] into a new array using +(_:_:) generic operator:

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

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

#2. Append the elements of an array into an existing array with Array's +=(_:_:) generic operator

Array has a +=(_:_:) generic operator. +=(_:_:) has the following declaration:

Appends the elements of a sequence to a range-replaceable collection.

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

The following Playground sample code shows how to append the elements of an array of type [Int] into an existing array using +=(_:_:) generic operator:

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

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

#3. Append an array to another array with Array's append(contentsOf:) method

Swift Array has an append(contentsOf:) method. append(contentsOf:) has the following declaration:

Adds the elements of a sequence or collection to the end of this collection.

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

The following Playground sample code shows how to append an array to another array of type [Int] using append(contentsOf:) method:

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

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

#4. Merge two arrays into a new array with Sequence's flatMap(_:) method

Swift provides a flatMap(_:) method for all types that conform to Sequence protocol (including Array). flatMap(_:) has the following declaration:

Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.

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

The following Playground sample code shows how to merge two arrays of type [Int] into a new array using flatMap(_:) method:

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. Merge two arrays into a new array with Sequence's joined() method and Array's init(_:) initializer

Swift provides a joined() method for all types that conform to Sequence protocol (including Array). joined() has the following declaration:

Returns the elements of this sequence of sequences, concatenated.

func joined() -> FlattenSequence<Self>

Besides, Swift Array has a init(_:) initializer. init(_:) has the following declaration:

Creates an array containing the elements of a sequence.

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

Therefore, the following Playground sample code shows how to merge two arrays of type [Int] into a new array using joined() method and init(_:) initializer:

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. Merge two arrays into a new array with Array's reduce(_:_:) method

Swift Array has a reduce(_:_:) method. reduce(_:_:) has the following declaration:

Returns the result of combining the elements of the sequence using the given closure.

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

The following Playground code shows how to merge two arrays of type [Int] into a new array using reduce(_:_:) method:

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]

How to copy elements of one array to another array in Java, are always clear about the types of values and keys that they can store. Want to concatenate or merge arrays in Swift? You can concatenate the arrays with +, building a new array.


If you are not a big fan of operator overloading, or just more of a functional type:

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

Collection Types, first.append(contentsOf: second). Another option is using the += operator, which is overloaded Duration: 1:05 Posted: Sep 19, 2019 - Check if object is an array - Concatenate arrays - Create an empty array - Filter an array based on condition - Find element index in array by value - Get array element at index - Get first element of array - Get last element of array - Get maximum element from array - Get minimum element from array - Get the size of an array - Insert item at array index


My favorite method since Swift 2.0 is flatten

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

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

This will return FlattenBidirectionalCollection so if you just want a CollectionType this will be enough and you will have lazy evaluation for free. If you need exactly the Array you can do this:

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

How to append one array to another array, Combine arrays. Programming languages have many syntaxes for combining 2 arrays. In Swift we use the plus operator. We can also append many elements  SWIFT 5 clean solution with O(N) where n is the count of elements in the smaller array. Using array slices . with generic min and max functions. The idea is to loop through the array which have less numbers. compare each opposite items then insert them in the result. after loop ended append rest items from longest array.


To complete the list of possible alternatives, reduce could be used to implement the behavior of flatten:

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

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

The best alternative (performance/memory-wise) among the ones presented is simply flatten, that just wrap the original arrays lazily without creating a new array structure.

But notice that flatten does not return a LazyCollection, so that lazy behavior will not be propagated to the next operation along the chain (map, flatMap, filter, etc...).

If lazyness makes sense in your particular case, just remember to prepend or append a .lazy to flatten(), for example, modifying Tomasz sample this way:

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

Swift Combine Arrays: append, contentsOf, How to concatenate or merge arrays in Swift,Swift Combine Arrays: append,swift 4 merge two arrays,swift concatenate array of strings,append  marked as duplicate by Wain, Hamish, vikingosegundo, ayaio swift May 5 '16 at 9:21. This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.


Concatenate/Merge Two Arrays into One Array in Swift 4, Reserves enough space to store the specified number of elements. Combining Arrays. func append<S>  - Append array to array - Append item to array - Check if 2 arrays are equal - Check if array contains element - Check if array is empty - Check if object is an array - Concatenate arrays - Create an empty array - Filter an array based on condition - Find element index in array by value - Get array element at index - Get first element of array


Array, Swift Standard Library. On This Page Declaration. mutating func append<S>(​contentsOf newElements: S) where Element == S.Element, S : Sequence Use this method to append the elements of a sequence to the end of this array. How to concatenate strings to make one joined string. Swift offers three different ways of joining strings. The first is using the + operator to join two strings to make a third: The last is using the += operator to add and assign a string to an existing string:


append(contentsOf:), or append one array to the other with += (or append a += b // Or: a.append(​contentsOf: b) // Swift 3 a.appendContentsOf(b) // Swift 2 a.extend(b) // Swift 1.2  NumPy’s concatenate function can be used to concatenate two arrays either row-wise or column-wise. Concatenate function can take two or more arrays of the same shape and by default it concatenates row-wise i.e. axis=0. The resulting array after row-wise concatenation is of the shape 6 x 3, i.e. 6 rows and 3 columns.