ios - item - swift merge arrays unique




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

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

Если есть два массива, созданных в быстром:

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

Как они могут быть объединены с [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, если «ключ» соответствует


Вы можете объединить массивы с помощью + , построив новый массив

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]

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

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

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

1. Слейте два массива в новый массив со Swift standard library оператором Swift standard library +(_:_:)

Стандартная библиотека Swift определяет общий оператор +(_:_:) . +(_:_:) имеет следующее declaration :

func +<RRC1 : RangeReplaceableCollection, RRC2 : RangeReplaceableCollection where RRC1.Iterator.Element == RRC2.Iterator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1

Создает новую коллекцию, объединяя элементы двух коллекций.

Следующий код игровой площадки показывает, как объединить два массива типа [Int] в новый массив, используя оператор +(_:_:) generic:

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

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

2. Добавьте массив в другой массив с помощью метода addend (contentOf append(contentsOf:) от Array

Swift Array имеет метод append(contentsOf:) . append(contentsOf:) имеет следующее declaration :

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

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

Следующий код игровой площадки показывает, как добавить массив в другой массив типа [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]

3. Объедините два массива в новый массив с flatMap(_:) метода flatMap(_:) Sequence

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

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

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

Следующий код игровой площадки показывает, как объединить два массива типа [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]

4. Слейте два массива в новый массив с помощью метода Array joined() Sequence и инициализатора инициализации Array init(_:)

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

func joined() -> FlattenSequence<Self>

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

Кроме того, Swift Array имеет init(_:) . init(_:) имеет следующее declaration :

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

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

Поэтому следующий код игровой площадки показывает, как объединить два массива типа [Int] в новый массив, используя метод init(_:) joined() и 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]

5. Слейте два массива в новый массив с помощью метода reduce(_:_:) Array reduce(_:_:)

Swift Array имеет метод reduce(_:_:) . reduce(_:_:) имеет следующее declaration :

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

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

Следующий код игровой площадки показывает, как объединить два массива типа [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]

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.

Благодарю.





append