小编Pab*_*lgo的帖子

在Spark Streaming中,可以(并且必须使用有状态操作)将StreamingContext检查点设置为(AND)的可靠数据存储(S3,HDFS,...):

• 元数据
• DStream 血统

如上所述这里,设置输出数据存储需要调用yourSparkStreamingCtx.checkpoint(datastoreURL)

另一方面,可以DataStream通过调用checkpoint(timeInterval)它们来为每个设置谱系检查点间隔.实际上,建议将谱系检查点间隔设置为DataStream滑动间隔的5到10倍:

dstream.checkpoint(checkpointInterval).通常,DStream的5-10个滑动间隔的检查点间隔是一个很好的设置.

我的问题是:

当流上下文设置为执行检查点并且没有ds.checkpoint(interval)被调用时,是否为所有数据流启用了谱系检查点,默认值checkpointInterval等于batchInterval？或者,相反,只有元数据检查点启用了什么？

大多数SQL实现(这个问题与SQL无关,它只是一个例子)提供函数COALESCE(x1,x2,...,xn),x1如果不是则返回NULL,x2否则只有在x2不是NULL等等的情况下才返回.如果所有xi值都是NULL结果则是NULL.

我希望COALESCE在Scala中获得类似SQL的内容,以便将Option值NULL替换为None.我会举几个例子:

> coalesce(None,Some(3),Some(4))
res0: Some(3)

> coalesce(Some(1),None,Some(3),Some(4))
res1: Some(1)

> coalesce(None,None)
res2: None

所以我把它实现为:

def coalesce[T](values: Option[T]*): Option[T] = 
    (List[T]() /: values)((prev: List[T], cur: Option[T]) =>
                          prev:::cur.toList).headOption

它工作正常,但我想知道是否已经存在类似于Scala的一部分实现的功能.

如果我没错,ISIN号码的最后位置是一个验证位.根据前11位数确定其值的数学函数是什么？

是否有任何哈希函数为具有相同元素的向量生成相同的桶,具有相同的相对位置但是移位了k次？

例如:

hash([1,9,8,7]) -> b1
hash([9,8,7,1]) -> b1

hash([1,8,9,7]) -> b2
hash([1,9,8,5]) -> b3

v1 = [1,9,8,7] v2 = [9,8,7,1]两个向量应该得到相同的散列,因为v2是v1左移k = 3次.

但是v3 = [1,8,9,7]不保持相同的相对顺序,并且v4 = [1,9,8,5]具有不同的值,因此它们都没有得到散列b1.

我最初的方法是计算每个向量的最大值,并将其位置视为参考(偏移= 0).拥有它我只需要移动每个向量,以便最大值始终位于第一个位置.这种方式移位的矢量看起来是一样的.然而,向量可以具有重复的元素,因此最大值具有不同的位置.

首先,我想明确表示我永远不会使用HashMap来处理需要在数据结构中有某种顺序的事情,并且这个问题是由我对Java HashMap实现的内部细节的好奇心所驱动的.

您可以在java文档中Object阅读有关该Object方法的信息hashCode.

我知道从那里hashCode上课的实施,如String和基本类型包装(Integer,Long一旦对象所包含的值给出,...)是可以预见的.例如,hashCode对String包含该值的任何对象的调用hello应始终返回:99162322

具有始终插入空Java HashMap的算法,其中Strings用作相同值的相同值的键.那么,它的元素在最后的顺序应该总是一样的,我错了吗？

由于具体值的哈希码始终相同,如果没有冲突,则顺序应该相同.另一方面,如果存在碰撞,我认为(我不知道事实)碰撞分辨率应该对完全相同的输入元素产生相同的顺序.

因此,具有相同元素的两个HashMap对象是否应该遍历(通过迭代器)给出相同的元素序列,这不是正确的吗？

如此处所述,在python中,可以使用以下命令替换当前模块实现sys.modules:

import somemodule

import sys
del sys.modules['somemodule']
sys.modules['somemodule'] = __import__('somefakemodule')

但是如果import somemodule在另一个导入模块的代码中完成它则不起作用:

在这个例子中:

CustomModule

import somemodule

def f():
    print(somemodule.someFunction())

ClientCode

from CustomModule import f

import sys
del sys.modules['somemodule']
sys.modules['somemodule'] = __import__('somefakemodule')    

f() #Will use `somemodule.someFunction`

呼叫f将使用somemodule.someFunction,而不是somefakemodule.someFunction

是否有可能使CustomModule代替其使用somemodule的somefakemodule,而不改变其代码？也就是说,来自ClientCode.

在Scala中,您可以执行以下操作:

def foo(implicit v: Int) = println(v);
def h(x: Int) = { implicit val i: Int = x; foo }

h(42)
> 42

hcall将foo引用作为闭包.

尝试传递foo给h参数并不奇怪:

def g(x: Int)(f: Int => Unit) = { implicit val i: Int = x; f }

但它不会起作用:

g(1)(foo)
> error: could not find implicit value for parameter v: Int

我认为它正在发生的是foo被称为实际参数的评估.是对的吗？

当传递具有普通参数列表的函数(非隐式)时,不会评估该函数:

def foo2(v: Int) = println("Foo2")
g(1)(foo2)
> Int => Unit = <function1>

这是预期结果,并且foo2 …

有几种计算机编程语言使用JVM字节码,比如说,它们的解释器/编译器的目标语言.在我看来,许多新的编程语言(不到15年)都在JVM上运行,我想知道是否所有这些语言都禁止显式内存释放:

是否可以通过任何指令使用字节码显式分配 - 释放内存？反过来说,垃圾收集器总是可以解释内存吗？

在SO处回答了一个问题,我找到了一个解决方案,如果有可能扩展Class类,那将是很好的:

这个解决方案包括尝试修饰Class类,以便只允许包含某些值,在本例中,是扩展具体类的类C.

public class CextenderClass extends Class
{
    public CextenderClass (Class c) throws Exception
    {
        if(!C.class.isAssignableFrom(c)) //Check whether is `C` sub-class
            throw new Exception("The given class is not extending C");
        value = c;
    }

    private Class value;

    ... Here, methods delegation ...
}

我知道这段代码不是Class最终的,我想知道为什么Class是最终的.我知道它必须与安全有关,但我无法想象延伸Class是危险的情况.你能举一些例子吗？

顺便说一下,我能达到的理想行为的更接近的解决方案是:

public class CextenderClass
{
    public CextenderClass(Class c) throws Exception
    {
        if(!C.class.isAssignableFrom(c)) //Check whether is `C` sub-class
            throw new Exception("The given class is …

Akka Testkit AutoPilot文档示例显示，TestProbe调用后我们可以将消息发送到右侧setAutoPilot：

  probe.setAutoPilot(new TestActor.AutoPilot {
    def run(sender: ActorRef, msg: Any): TestActor.AutoPilot =
      msg match {
        case "stop" ? TestActor.NoAutoPilot
        case x      ? testActor.tell(x, sender); TestActor.KeepRunning
      }
  })
  //#autopilot
  probe.ref ! "hallo"

另一方面setAutoPilot已实现为向发送消息testActor：

def setAutoPilot(pilot: TestActor.AutoPilot): Unit = testActor ! TestActor.SetAutoPilot(pilot)

根据Akka消息接收顺序保证，testActor（probe.ref）"hallo"之前无法接收， TestActor.SetAutoPilot(pilot)因为两者都是从同一来源发送的。

但是，如果我们使用第三个参与者（使用创建的system.actorOf(...)）将发送"hello"给probe.ref，

在某些情况下，probe.ref在TestActor.SetAutoPilot(pilot)被最终忽略之前，它是否有可能被接收？