Answers:
您可以使用串联数组+
,建立一个新数组
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]
AnyObject
表示一个对象,据我了解,它是指从类类型实例化的对象。CGFloat
不是对象,而是标量值。据我了解,数组可以包含标量,除非将其定义为包含标量AnyObject
或进一步完善。但是,我怀疑这里的问题是数组包装在一个可选包装中,因此您必须先用!
或将其拆开?
。
b
一部分是否a
被修改(因此有可能b
在期间删除的副本a.appendContentsOf(b)
)?
使用Swift 5,您可以根据需要选择以下六种方法之一来串联/合并两个数组。
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]
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]
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]
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]
Sequence
的joined()
方法和初始化器将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]
使用joined()
method和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
的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]
+
2个数组和joined()
一个数组。
+
运算符,那么它将产生绝对疯狂的编译时间。
自从Swift 2.0 展平以来,我最喜欢的方法
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())
为了完成可能的选择列表,reduce
可以用来实现flatten的行为:
var a = ["a", "b", "c"]
var b = ["d", "e", "f"]
let res = [a, b].reduce([],combine:+)
在介绍的方法中,最好的替代方法(从性能/内存角度flatten
来看)很简单,即只是懒散地包装原始数组,而无需创建新的数组结构。
但是请注意,扁平化 不返回一个LazyCollection
,让懒惰行为不会传播到沿链(地图,flatMap,过滤器,等...)下一步的操作。
如果在您的特定情况下懒惰是有意义的,则只需记住在前面加上或.lazy
即可flatten()
,例如,以这种方式修改Tomasz示例:
let c = [a, b].lazy.flatten()
斯威夫特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 array1 = [1,2,3]
let array2 = [4,5,6]
串联/合并它们
array1 += array2
New value of array1 is [1,2,3,4,5,6]
不同数据类型的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]]