小编Chi*_*rlo的帖子

Java事件日志记录(分析)库有一个方法,它接受事件名称,然后是字符串的varargs列表,如下所示:

Analytics.event("my event name", "key1", "value1", "key2", "value2" ...)

我已将我的事件参数收集到Map中

Map("key1" -> "value1", "key2" -> "value2" ...)

现在必须有一种方法来展平Map键和值交替的列表,然后将其提供给事件方法.我已经进行了几次猜测,比如转换Map为列出List的Tuples,但是调用.flatten就可以了

No implicit view available from (java.lang.String, java.lang.String) => scala.collection.TraversableOnce[B]

我在这里错过了什么？

我有一个val it:Iterator[(A,B)],我想SortedMap[A,B]用我得到的元素创建一个Iterator.我现在这样做的方式是:

val map = SortedMap[A,B]() ++ it

它工作正常,但使用感觉有点尴尬.我检查了SortedMap文档,但找不到更优雅的东西.是否有类似的东西:

 it.toSortedMap 

要么

SortedMap.from(it)

在标准的Scala库中,我可能错过了？

编辑:混合来自@ Rex答案的两个想法我想出了这个:

SortedMap(it.to:_*)

哪个工作正常,并避免必须指定类型签名SortedMap.虽然看起来仍然很有趣,但欢迎进一步的答案.

我在java中有以下层次结构:

interface ObserverA {}

interface A {
  void method1();
  addObserver(Observer o);
}

我想像这样扩展它:

interface ObserverB extends ObserverA{}

interface B extends A {
   void method2();
   addObserver(ObserverB  o);
}

以这种方式,addObserver()方法B将覆盖相同的方法A.因为它不起作用,实现B将需要实现两个版本addObserver(),我不会只有一个.

这可以通过一种不需要参数化的聪明方式完成A:

interface A<O extends Observer> { 
    addObserver(O o);
}

Hackish解决方案非常受欢迎!

我正在尝试使用Scala运行XPath查询，但它似乎不起作用。我的Xml看起来像（简化）：

<application>
  <process type="output" size ="23"> 
     <channel offset="0"/>
      ....
     <channel offset="4"/>
  </process>
  <process type="input" size ="16"> 
     <channel offset="20"/>
      ....
     <channel offset="24"/>
  </process>
</application>

我想process使用input属性来检索，为此，我使用以下XPath查询：

//process[@type='input']

这应该可行，我用xpathtester验证了它， 现在，我的scala代码如下所示：

import scala.xml._
val x = XML.loadFile("file.xml")

val process = (x \\ "process[@type='input']")  // will return empty NodeSeq() !!!

该process补虚结束，但这并没有捕捉我想要什么。我像这样工作：

val process = (x \\ "process" filter( _ \"@type" contains Text("input")))

这很丑。我的原始查询不起作用的任何已知原因？

我正在尝试路径依赖类型,并在尝试为其编写scalaz.Equal实例时遇到问题.我有以下结构:

class A {
  class B 
}

val a1 = new A 
val b1 = new a1.B   // type a1.B

val a2 = new A 
val b2 = new a2.B   //type a2.B

我首先想在编译时制作b1"无与伦比的"(这是一个单词？)b2,这是我用以下方法实现的:

import scalaz._
import Scalaz._

implicit def BEqual[X <: A#B]: scalaz.Equal[X] = Equal.equalA

b1 === b1 //true
b1 === b2 // doesn't compile, good
b2 === b1 // doesn't compile, good 

我的第二个实验是尝试使等同性更少限制,允许实例A#B相互比较而不是其他类型,具有:

 implicit val  BEqual: scalaz.Equal[A#B] = Equal.equalA

但它不能按预期工作:

b1 …

我使用我的自签名证书运行kube-apiserver：

/opt/bin/kube-apiserver \
--etcd_servers=http://master:2379,http://slave1:2379,http://slave2:2379 \
--logtostderr=false \
--v=4 \
--client-ca-file=/home/kubernetes/ssl/ca.crt \
--service-cluster-ip-range=192.168.3.0/24 \
--tls-cert-file=/home/kubernetes/ssl/server.crt \
--tls-private-key-file=/home/kubernetes/ssl/server.key

然后，我使用kubeconfig运行kubelet：

/opt/bin/kubelet \
--address=0.0.0.0 \
--port=10250 \
--api_servers=https://master:6443 \
--kubeconfig=/home/kubernetes/ssl/config.yaml \
--logtostderr=false \
--v=4

config.yaml的内容如下：

apiVersion: v1
kind: Config
clusters:
- name: ubuntu
  cluster:
    insecure-skip-tls-verify: true
    server: https://master:6443
contexts:
- context:
    cluster: "ubuntu"
    user: "ubuntu"
  name: development
current-context: development
users:
- name: ubuntu
  user:
    client-certificate: /home/kubernetes/ssl/ca.crt
    client-key: /home/kubernetes/ssl/ca.key

因此，我认为kubelet不会验证apiserver的自签名证书，但是日志显示：

E1009 16:48:51.919749  100724 reflector.go:136] Failed to list *api.Pod: Get https://master:6443/api/v1/pods?fieldSelector=spec.nodeName%3Dslave1: x509: certificate signed by unknown …

我不明白使用和之间的区别,然后是空,然后很多和flatMapMany在春天webflux上的Flux或Mono.

根据一些体育成绩数据,我有一个Fixture对象getHome()和getAway()方法.我想缩短这个我写的方法,只使用一个lambda函数(而不是创建一个新列表和两个lambdas),这可能吗？

    private Collection<FixtureResult> finalResults(Team team) {

    List<FixtureResult>finalResults = new ArrayList<>();

    List<FixtureResult> homeResults = resultList.stream().filter(fixture ->
            fixture.getHome().equals(team))
            .collect(toList());

    List<FixtureResult> awayResults = resultList.stream().filter(fixture ->
            fixture.getAway().equals(team))
            .collect(toList());

    finalResults.addAll(homeResults);
    finalResults.addAll(awayResults);

    return finalResults;
}

考虑以下层次结构:

class C1
class C2 extends C1
class C3 extends C2
class C4 extends C3

我想编写一个只接受类型C2和函数的函数C3.为此我想到了以下内容:

 def f [C >: C3 <: C2](c :C) = 0

我期待以下行为

f(new C1)  //doesn't compile, ok
f(new C2)  //compiles, ok
f(new C3)  //compiles, ok
f(new C4)  // !!! Compiles, and it shouldn't 

问题是在调用它时C4,我不想允许,但编译器接受.我明白这C4 <: C2是正确的,C4可以看作是一个C3.但是在指定边界时[C >: C3 <: C2],我希望编译器能够找到一个C同时尊重两个边界的东西,而不是一个接一个.

问题是:有没有办法实现我想要的,如果没有,编译器是否试图避免与此有些不一致？

编辑:从答案中我意识到我的推定是错误的.C4永远满足C >: C3,所以两个界限确实得到尊重.我的用例的方法是 …

我在Java - Maven - Jenkins项目上使用语义版本控制,因此,每当完成不兼容的API更改时,应更改产品的主要版本.我正在寻找一种自动检测这种变化的方法,以便maven构建在发生时会失败(甚至自动增加版本).谷歌搜索让我在编写自己的maven enforcer plugin规则的轨道上,但我想询问是否有人知道任何可以提供帮助的工具(Jenkins插件或类似工具也可以工作).

我正在尝试用基于属性的测试 (PBT) 替换一些旧的单元测试，具体地用scala和scalatest - scalacheck但我认为这个问题更普遍。简化的情况是，如果我有要测试的方法：

 def upcaseReverse(s:String) = s.toUpperCase.reverse

通常，我会编写单元测试，例如：

assertEquals("GNIRTS", upcaseReverse("string"))
assertEquals("", upcaseReverse(""))
// ... corner cases I could think of

所以，对于每个测试，我写出我期望的输出，没问题。现在，使用 PBT，它会像：

property("strings are reversed and upper-cased") {
 forAll { (s: String) =>
   assert ( upcaseReverse(s) == ???) //this is the problem right here!
 }
}

当我尝试编写一个对所有String输入都适用的测试时，我发现自己不得不在测试中再次编写方法的逻辑。在这种情况下，测试将如下所示：

   assert ( upcaseReverse(s) == s.toUpperCase.reverse) 

也就是说，我必须在测试中编写实现以确保输出正确。有没有办法解决这个问题？我是否误解了 PBT，我是否应该测试其他属性，例如：

• “字符串的长度应与原始字符串的长度相同”
• “字符串应该包含原始的所有字符”
• “字符串不应包含小写字符”...

这也是合理的，但听起来很做作，不太清楚。任何在 PBT 方面有更多经验的人都可以在这里解释一下吗？

编辑：按照@Eric 的消息来源，我找到了这篇文章，并且有一个我的意思的示例（在再次应用类别时）：测试times( F#) 中的方法 …

我是Scala的新手,所以希望你能在这个问题中容忍这个问题,如果你发现它是noobish :)

我写了一个函数,它使用yield语法返回一个Seq元素:

def calculateSomeMetrics(names: Seq[String]): Seq[Long] = {
  for (name <- names) yield {
    // some auxiliary actions
    val metrics = somehowCalculateMetrics()
    metrics
  }
}

现在我需要修改它以返回Map以保留原始名称对每个计算值:

def calculateSomeMetrics(names: Seq[String]): Map[String, Long] = { ... }

我试图使用相同的yield语法,但产生一个元组而不是单个元素:

def calculateSomeMetrics(names: Seq[String]): Map[String, Long] = {
  for (name <- names) yield {
    // Everything is the same as before
    (name, metrics)
  }
}

但是,编译器会Seq[(String, Long)]根据编译器错误消息对其进行解释

type mismatch;
  found   : Seq[(String, Long)]
  required: Map[String, Long]

所以我想知道,实现这样的事情的"规范Scala方式"是什么？

我希望创建一个函数f,它获得一个名为n的类型的参数Number.但是我还要指定n必须是Comparable(哪些是AtomicInteger和AtomicLong不是).我怎么写这个功能？

我试过这个:public static <T extends Number, Comparable<T>> void f(T n)但是这没用.我怎么解决这个问题？