在Scala中合并两个数组

我的要求是：

arr1 : Array[(String, String)] = Array((bangalore,Kanata),  (kannur,Kerala)) 
arr2 : Array[(String, String)] = Array((001,anup), (002,sithu))

应该给我

Array((001,anup,bangalore,Krnata), (002,sithu,kannur,Kerala))

我试过这个：

val arr3 = arr2.map(field=>(field,arr1))

---

但是它不起作用

你可以先做一个

zip

，然后再做一个

map

：

scala> val arr1 = Array((1,2),(3,4))
arr1: Array[(Int, Int)] = Array((1,2), (3,4))

scala> val arr2 = Array((5,6),(7,8))
arr2: Array[(Int, Int)] = Array((5,6), (7,8))

scala> arr1.zip(arr2).map(field => (field._1._1, field._1._2, field._2._1, field._2._2))
res1: Array[(Int, Int, Int, Int)] = Array((1,2,5,6), (3,4,7,8))

map

充当元组的扁平化，即获取

（（a，B），（C，D））

类型的事物，并将它们映射到

（a，B，C，D）

zip

所做的是。。。嗯，让我们看看它的类型：

def zip[B](that: GenIterable[B]): List[(A, B)]

---

因此，从这里，我们可以说它接受一个iterable集合（可以是另一个列表），并返回一个列表，该列表是

this:list[a]

和

this:list[B]

列表的对应元素的组合。回想一下，如果一个列表比另一个列表大，则忽略其其余元素。您可以在中深入了解有关列表函数的更多信息。

您可以先执行

zip

，然后执行

map

：

scala> val arr1 = Array((1,2),(3,4))
arr1: Array[(Int, Int)] = Array((1,2), (3,4))

scala> val arr2 = Array((5,6),(7,8))
arr2: Array[(Int, Int)] = Array((5,6), (7,8))

scala> arr1.zip(arr2).map(field => (field._1._1, field._1._2, field._2._1, field._2._2))
res1: Array[(Int, Int, Int, Int)] = Array((1,2,5,6), (3,4,7,8))

map

充当元组的扁平化，即获取

（（a，B），（C，D））

类型的事物，并将它们映射到

（a，B，C，D）

zip

所做的是。。。嗯，让我们看看它的类型：

def zip[B](that: GenIterable[B]): List[(A, B)]

因此，从这里，我们可以说它接受一个iterable集合（可以是另一个列表），并返回一个列表，该列表是

this:list[a]

和

this:list[B]

列表的对应元素的组合。回想一下，如果一个列表比另一个列表大，则忽略其其余元素。您可以在中进一步了解列表函数。

很好地解决了您的问题

zip

然后

map

将为您提供结果数组

回想一下，如果一个列表比另一个列表大，则忽略其其余元素。 我试图解决这个问题：

考虑：

val arr1 =  Array(("bangalore","Kanata"),  ("kannur","Kerala"))

val arr2 = Array(("001","anup", "ramakrishan"), ("002","sithu", "bhattacharya"))

zip

和元组映射将给出如下结果：

arr1.zip(arr2).map(field => (field._1._1, field._1._2, field._2._1, field._2._2))
Array[(String, String, String, String)] = Array((bangalore,Kanata,001,anup), (kannur,Kerala,002,sithu)) 
// This ignores the last field of arr2

映射时，可以在迭代器中转换元组并从中获取列表。这将使您不必跟踪

Tuple2

或

Tuple3

arr1.zip(arr2).map{ case(k,v) => List(k.productIterator.toList, v.productIterator.toList).flatten }
// Array[List[Any]] = Array(List(bangalore, Kanata, 001, anup, ramakrishan), List(kannur, Kerala, 002, sithu, bhattacharya))

很好地回答了你的问题

zip

然后

map

将为您提供结果数组

回想一下，如果一个列表比另一个列表大，则忽略其其余元素。 我试图解决这个问题：

考虑：

val arr1 =  Array(("bangalore","Kanata"),  ("kannur","Kerala"))

val arr2 = Array(("001","anup", "ramakrishan"), ("002","sithu", "bhattacharya"))

zip

和元组映射将给出如下结果：

arr1.zip(arr2).map(field => (field._1._1, field._1._2, field._2._1, field._2._2))
Array[(String, String, String, String)] = Array((bangalore,Kanata,001,anup), (kannur,Kerala,002,sithu)) 
// This ignores the last field of arr2

映射时，可以在迭代器中转换元组并从中获取列表。这将使您不必跟踪

Tuple2

或

Tuple3

arr1.zip(arr2).map{ case(k,v) => List(k.productIterator.toList, v.productIterator.toList).flatten }
// Array[List[Any]] = Array(List(bangalore, Kanata, 001, anup, ramakrishan), List(kannur, Kerala, 002, sithu, bhattacharya))

---

我同意Cleans解决方案使用集合中的zip方法

val arr1 = Array(("bangalore","Kanata"),  ("kannur","Kerala"))
val arr2 = Array(("001","anup"), ("002","sithu"))

arr1.zip(arr2).foldLeft(List.empty[Any]) {
  case (acc, (a, b)) => acc ::: List(a.productIterator.toList ++ b.productIterator.toList)
}

---

我同意Cleans解决方案使用集合中的zip方法

val arr1 = Array(("bangalore","Kanata"),  ("kannur","Kerala"))
val arr2 = Array(("001","anup"), ("002","sithu"))

arr1.zip(arr2).foldLeft(List.empty[Any]) {
  case (acc, (a, b)) => acc ::: List(a.productIterator.toList ++ b.productIterator.toList)
}

---

显然，

map

将不起作用，因为这会迭代集合的项。如果您想纯粹附加集合，请查看它，看起来您实际上想要

zip

这两个数组。显然，

map

将不起作用，因为这会迭代集合的项。如果您想纯粹附加集合，请查看它，看起来您实际上想要

zip

这两个数组。