小编dav*_*vid的帖子

我需要将两个Future [List]合并为一个,我想出了以下解决方案:

    def mergeFutureLists[X]( fl1: Future[List[X]], fl2: Future[List[X]] ): Future[List[X]] =
    {
        val lf = List( fl1, fl2 )
        val fll = Future.sequence( lf )
        return fll.map{ x => x.flatMap{ el => el } }
    }

它做我想要的,但它是正确的方式进行？

这是一个简单的代码示例来说明我的问题：

case class Record( key: String, value: Int )

object Job extends App
{
  val env = StreamExecutionEnvironment.getExecutionEnvironment
  val data = env.fromElements( Record("01",1), Record("02",2), Record("03",3), Record("04",4), Record("05",5) )
  val step1 = data.filter( record => record.value % 3 != 0  ) // introduces some data loss
  val step2 = data.map( r => Record( r.key, r.value * 2 ) )
  val step3 = data.map( r => Record( r.key, r.value * 3 ) )
  val merged = step1.union( step2, step3 )
  val keyed …

有没有办法在 SparkConf 中指定多个 MongoDB 主机？文档中的示例（https://docs.mongodb.com/spark-connector/v1.1/configuration/）似乎表明没有。

spark.mongodb.output.uri=mongodb://127.0.0.1/
spark.mongodb.output.database=test
spark.mongodb.output.collection=myCollection

假设我有两个类C1和C2，其中C2由C1的构造函数使用：

public class C1
{
    public C1( C2 o2 ){ ... }

    public String getProperty()
    {
        String result;
        ...
        return result;
    }
}

现在，我有了一个C2对象列表（列表列表），我想使用从流C2对象创建的C1的getProperty（）上的条件来流式传输和过滤。

有没有办法用流来做到这一点？

List<C2> list = ...
List<C2> result = list.stream().filter( XXXX )

我猜我应该有XXXX，它使用流中的C2对象创建一个C1对象并比较其getProperty（）（例如，“ value” .equals（o2.getProperty（）））

这有可能吗？

我有可选列表，例如：

val optionalEmptyList = Option(List[String]())

val optionalNonEmptyList = Option(List[String]("1","2"))

我想用 None 替换可选的空列表，同时保持可选的非空列表原样。

我想出了以下解决方案：

optionalEmptyList.flatMap(l => if (l.isEmpty) None else Option(l))

optionalNonEmptyList.flatMap(l => if (l.isEmpty) None else Option(l))

它有效，但似乎令人费解。有没有更简单的解决方案？

我有一张地图清单:

val input = List( Map("id" -> "abc", "val" -> 100), 
                  Map("id" -> "abc", "val" -> 109), 
                  Map("id" -> "bca", "val" -> 115), 
                  Map("id" -> "acb", "val" -> 100), 
                  Map("id" -> "cba", "val" -> 105),
                  Map("id" -> "cba", "val" -> 110), 
                  Map("id" -> "cba", "val" -> 116) )

我需要从中过滤出所有共享密钥"id"的公共值的地图.换句话说,我必须只保留key id的值唯一的映射.

val output = List( Map("id" -> "bca", "val" -> 115), 
                   Map("id" -> "acb", "val" -> 100) )

使用 Akka classic，人们可以轻松实现一项服务（作为参与者：ServiceActor）

• 接收来自不同参与者的请求（即不同类型的参与者：RequestorA、RequestorB等），
• 处理请求，
• 向请求者发回确认。

RequestorA 向 ServiceActor 发送 RequestMessage ServiceActor 向 RequestorA 发回 Acknowledgment

类似地，RequestorB 向 ServiceActor 发送 RequestMessage，ServiceActor 向 RequestorB 发回 Acknowledgment

无论Requestor是什么，都只有一种类型的RequestMessage和Acknowledgment，并且所有RequestMessage都由ServiceActor以相同的方式处理。

使用 Akka Typed 实现类似功能的方法是什么？既然请求消息必须包含显式的replyTo：ActorRef[RequestorA.Message]，是否有办法避免为每个请求者实现不同的RequestMessage？

• RequestFromRequestorA（回复：ActorRef[RequestorA.Message]）
• RequestFromRequestorB（回复：ActorRef[RequestorB.Message]）

同样，是否有办法避免向每种类型的请求者发回不同类型的确认？