Arrays 同时迭代两个数组

我不熟悉斯威夫特。我一直在做Java编程。我要用Swift编写一个场景

下面的代码是用Java编写的。我需要为以下场景编写Swift代码

// With String array - strArr1
String strArr1[] = {"Some1","Some2"}

String strArr2[] = {"Somethingelse1","Somethingelse2"}

for( int i=0;i< strArr1.length;i++){
    System.out.println(strArr1[i] + " - "+ strArr2[i]);
}

请提供您对基于索引循环的语法的帮助（var i=0；ifor(var i = 0; i < strArr1.count ; i++) { println(strArr1[i] + strArr2[i]) } { println（strArr1[i]+strArr2[i]） } 应该这样做。以前从未使用过swift，因此请务必进行测试

更新到最新的Swift语法

0中的i的

。

您还可以

枚举一个数组，并使用索引查看第二个数组的内部：

Swift 1.2：

for (index, element) in enumerate(strArr1) {
    println(element)
    println(strArr2[index])
}

Swift 2：

for (index, element) in strArr1.enumerate() {
    print(element)
    print(strArr2[index])
}

Swift 3：

for (index, element) in strArr1.enumerated() {
    print(element)
    print(strArr2[index])
}

如果您仍然想在

中使用for，可以使用

范围

var strArr1: [String] = ["Some1","Some2"]
var strArr2: [String] = ["Somethingelse1","Somethingelse2"]

for i in Range(start: 0, end: strArr1.count) {
    println(strArr1[i] + " - " + strArr2[i])
}

您可以使用

zip（）

，它创建 两个给定序列中的成对序列：

let strArr1 = ["Some1", "Some2"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

for (e1, e2) in zip(strArr1, strArr2) {
    print("\(e1) - \(e2)")
}

序列仅枚举给定序列/数组的“公共元素”。如果长度不同，则附加的 较长数组/序列的元素将被忽略。

尝试以下操作：

zip([0,2,4,6], [1,3,5,7]).forEach {
    print($0,$1)
}

zip([0,2,4,6], [1,3,5,7]).forEach {
    print($0.0,$0.1)
}

---

使用Swift 5，您可以使用以下4个游乐场代码之一来解决您的问题

---

#1.使用功能 在最简单的情况下，您可以使用

zip（::）

创建初始数组元素的新成对序列（元组）

let strArr1 = ["Some1", "Some2", "Some3"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

let sequence = zip(strArr1, strArr2)

for (el1, el2) in sequence {
    print("\(el1) - \(el2)")
}

/*
 prints:
 Some1 - Somethingelse1
 Some2 - Somethingelse2
 */

---

#2.使用

数组的方法和while循环
使用一个简单的while循环和迭代器，同时在两个数组上循环也很容易：

let strArr1 = ["Some1", "Some2", "Some3"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

var iter1 = strArr1.makeIterator()
var iter2 = strArr2.makeIterator()

while let el1 = iter1.next(), let el2 = iter2.next() {
    print("\(el1) - \(el2)")
}

/*
 prints:
 Some1 - Somethingelse1
 Some2 - Somethingelse2
 */


#3.使用符合以下条件的自定义类型
在某些情况下，您可能希望创建自己的类型，该类型与初始值数组的元素配对。这可以通过使您的类型符合
IteratorProtocol
来实现。请注意，通过使您的类型也符合
序列
协议，您可以在for循环中直接使用它的实例：

struct TupleIterator: Sequence, IteratorProtocol {

    private var firstIterator: IndexingIterator<[String]>
    private var secondIterator: IndexingIterator<[String]>

    init(firstArray: [String], secondArray: [String]) {
        self.firstIterator = firstArray.makeIterator()
        self.secondIterator = secondArray.makeIterator()
    }

    mutating func next() -> (String, String)? {
        guard let el1 = firstIterator.next(), let el2 = secondIterator.next() else { return nil }
        return (el1, el2)
    }

}

let strArr1 = ["Some1", "Some2", "Some3"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

let tupleSequence = TupleIterator(firstArray: strArr1, secondArray: strArr2)

for (el1, el2) in tupleSequence {
    print("\(el1) - \(el2)")
}

/*
 prints:
 Some1 - Somethingelse1
 Some2 - Somethingelse2
 */

//结果：[“some1-some1”、“some2-some2”、“some3”]
您的java代码一开始是不安全的，因为它假设strArr2的长度与StrArr1相同或更长（在硬编码数组中可以工作，但在数组可以更改的代码中则无法工作）。是的，java代码只是一个示例。我们检查strArr1.length==strArr2.length，否则返回。那么zip（）接受2个数组，并返回两个数组中公共元素的元组数组？是
zip（）
swift 2语法，还是
zip2
？你的第一句话暗示
zip
是swift 1.2语法，但最后一位听起来像
zip
是swift 2语法。@Duncac:你说得对，上一次编辑有误导性。
zip（）
函数在Swift 1.2和Swift 2中都起作用，只有底层序列类型从
Zip2
更改为
Zip2Sequence
它接受两个序列（数组只是一个特例）并返回一个（延迟计算的）序列，其中包含公共元素的元组。我们可以打印两个不同大小数组的所有元素吗？为什么它们都必须具有相同的类型？这似乎是一个毫无意义的限制：我的问题与类型无关；不管怎样，我还是遇到了同样的错误：无法使用类型为“（[Float]、[Float]、[Float]）”的参数列表调用“zip”。@pete:Swift
zip
函数将两个序列作为参数、比较或在Swift论坛中使用。这对strArr1.enumerate（）进行了更改在最新版本的swift中。如果第一个数组的元素多于第二个数组，则此代码将崩溃。你应该在for循环的开头添加
guard strArr2.index.contains（index）else{break}
，以确保安全。C风格的for循环在Swift 3.0中不受欢迎。谢谢@popckernel，在Swift 3.0推出之前发布了这篇文章。我没有批评，只是为其他人添加了这些信息。我不认为你是这样@Popckernelor shorter:对于0中的i..请更新您的Ans。如果您不知道数组的大小，那么它将无法工作。太好了！这也适用于不同大小的阵列Love zip！我从来不知道。。。。我总是使用计数器来迭代循环。。。我和我的C代码技能哈哈！
let strArr1 = ["Some1", "Some2", "Some3"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

var iter1 = strArr1.makeIterator()
var iter2 = strArr2.makeIterator()

while let el1 = iter1.next(), let el2 = iter2.next() {
    print("\(el1) - \(el2)")
}

/*
 prints:
 Some1 - Somethingelse1
 Some2 - Somethingelse2
 */

struct TupleIterator: Sequence, IteratorProtocol {

    private var firstIterator: IndexingIterator<[String]>
    private var secondIterator: IndexingIterator<[String]>

    init(firstArray: [String], secondArray: [String]) {
        self.firstIterator = firstArray.makeIterator()
        self.secondIterator = secondArray.makeIterator()
    }

    mutating func next() -> (String, String)? {
        guard let el1 = firstIterator.next(), let el2 = secondIterator.next() else { return nil }
        return (el1, el2)
    }

}

let strArr1 = ["Some1", "Some2", "Some3"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

let tupleSequence = TupleIterator(firstArray: strArr1, secondArray: strArr2)

for (el1, el2) in tupleSequence {
    print("\(el1) - \(el2)")
}

/*
 prints:
 Some1 - Somethingelse1
 Some2 - Somethingelse2
 */

extension Array {

    func pairWithElements(of array: Array) -> AnyIterator<(Element, Element)> {
        var iter1 = self.makeIterator()
        var iter2 = array.makeIterator()

        return AnyIterator({
            guard let el1 = iter1.next(), let el2 = iter2.next() else { return nil }
            return (el1, el2)
        })
    }

}

let strArr1 = ["Some1", "Some2", "Some3"]
let strArr2 = ["Somethingelse1", "Somethingelse2"]

let iterator = strArr1.pairWithElements(of: strArr2)

for (el1, el2) in iterator {
    print("\(el1) - \(el2)")
}

/*
 prints:
 Some1 - Somethingelse1
 Some2 - Somethingelse2
 */

> Incase of unequal count 

let array1 = ["some1","some2"]
let array2 = ["some1","some2","some3"]

var iterated = array1.makeIterator()
let finalArray = array2.map({ 
                 let itemValue = iterated.next()
                 return "\($0)\(itemValue != nil ? "-"+itemValue! : EmptyString)" })