If you want the second array to be inserted after a particular index you can do this (as of 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]
Marge array that are different data types :
var arrayInt = [Int]()
arrayInt.append(6)
var testArray = ["a",true,3,"b"] as [Any]
testArray.append(someInt)
Output :
["a", true, 3, "b", "hi", 3, [6]]
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 3.0
You can create a new array by adding together two existing arrays with compatible types with the addition operator (+
). The new array's type is inferred from the type of the two array you add together,
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]
this is the right results of above codes.
Similarly, with dictionaries of arrays one can:
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"]!)
and you can iterate over dict1 and add dict2 if the "key" matches
Swift 4.X
easiest way I know is to just use the + sign
var Array1 = ["Item 1", "Item 2"]
var Array2 = ["Thing 1", "Thing 2"]
var Array3 = Array1 + Array2
// Array 3 will just be them combined :)
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())
var arrayOne = [1,2,3]
var arrayTwo = [4,5,6]
if you want result as : [1,2,3,[4,5,6]]
arrayOne.append(arrayTwo)
above code will convert arrayOne as a single element and add it to the end of arrayTwo.
if you want result as : [1, 2, 3, 4, 5, 6] then,
arrayOne.append(contentsOf: arrayTwo)
above code will add all the elements of arrayOne at the end of arrayTwo.
Thanks.
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]
With Swift 5, according to your needs, you may choose one of the six following ways to concatenate/merge two arrays.
Array
's +(_:_:)
generic operatorArray
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]
Array
's +=(_:_:)
generic operatorArray
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]
Array
's append(contentsOf:)
methodSwift 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]
Sequence
's flatMap(_:)
methodSwift 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]
Sequence
's joined()
method and Array
's init(_:)
initializerSwift 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]
Array
's reduce(_:_:)
methodSwift 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]
Here's the shortest way to merge two arrays.
var array1 = [1,2,3]
let array2 = [4,5,6]
Concatenate/merge them
array1 += array2
New value of array1 is [1,2,3,4,5,6]
Swift 5 Array Extension
extension Array where Element: Sequence {
func join() -> Array<Element.Element> {
return self.reduce([], +)
}
}
Example:
let array = [[1,2,3], [4,5,6], [7,8,9]]
print(array.join())
//result: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Source: Stackoverflow.com