Scala-通过公共元素合并两个元组列表

Question

How to merge two lists of tuples that simulates Chasles' Relation?

(a, b), (b, c) => (a, c)

Here is an example:

val l1 = List(("Dan", "b"), ("Dan","a"), ("Bart", "c"))
val l2 = List(("a", "1"), ("c", "1"), ("b", "3"), ("a", "2"))

Expected result would be:

val result = List(("Dan", "3"), ("Dan", "1"), ("Dan", "2"), ("Bart", "1"))

Answer 1

You basically want to consider all pairs of one element from the first list and one from the second and keep those where the "b" elements match.

In other words, we want to map over l1 and, inside that map, map over l2 , meaning we consider all the pairs of an element from each list, so something like:

l1.map(x => l2.map(y => (x,y))

That's not quite right, though, since we now have a List[List[((String, String),(String,String))]] --we needed to flatmap:

l1.flatMap(x => l2.map(y => (x,y)))

Now we have to filter to keep just the pairs we want and tidy up:

l1.flatMap(x => l2.map(y => (x,y)))
  .filter{ case ((_,y),(b,_)) => y == b }
  .map {case ((x, _),(_,c)) => (x,c) }

which gives us

List((Dan,3), (Dan,1), (Dan,2), (Bart,1))

That was kind of an ugly mess, so and we can tidy it up a bit--let's filter l2 in our original flatmap and build the result there, so we don't have to juggle the tuple of tuples:

l1.map{ case (x,y) => 
    l2.filter{ case (b, _) => y == b}
      .map{ case (_, c) => (x, c)} }

This is one of those cases where it's easier to read a for comprehension:

for {
  (x, y) <- l1
  (b, c) <- l2
  if y == b
} yield (x,c)

Answer 2

For each tuple in l1 you can filter l2 to select the tuples with the matching first element:

def join[A, B, C](l1: List[(A, B)], l2: List[(B, C)]): List[(A, C)] = {
  for {
    (key, subkey) <- l1
    value <- l2.collect { case (`subkey`, value) => value }
  } yield key -> value  
}

You could also convert l2 into a Map beforehand for better selection performance:

def join[A, B, C](l1: List[(A, B)], l2: List[(B, C)]): List[(A, C)] = {
  val valuesMap = l2.groupBy(_._1)
  for {
    (key, subkey) <- l1
    (_, value) <- valuesMap.getOrElse(subkey, Nil)
  } yield key -> value  
}