我有以下列表:

case class myPair(ids:Int,vals:Int)

val someTable = List((20,30), (89,90), (40,65), (45,75), (35,45))

val someList:List[myPair] =
  someTable.map(elem => myPair(elem._1, elem._2)).toList

我想过滤所有"ids"> 45.我试过类似这篇文章的过滤器使用模式匹配):

someList.filter{ case(myPair) => ids >= 45 }

但没有成功.感谢您的帮助

我有两个特点

trait Person
trait Food

为什么这是编译:

val pf = new Person with Food //OK

而事实并非如此

val p = new Person //result  error: trait Person is abstract; cannot be instantiated

我如何将这个旧代码迁移到scala 2.10,因为scala.util.Marshal已被弃用？

object Serilaizer{
 def objectToBytes[T](foo: T)(implicit expected: ClassManifest[T]): Array[Byte] = {
    Marshal.dump(foo)
  }
  def bytesToObject[T](fooBytes: Array[Byte])(implicit expected: ClassManifest[T]): Option[T] = {
    Some(Marshal.load[T](fooBytes))
    }
  }

我看到了SBinary,但尚未发布.

我试图在使用约束注释反序列化时验证json,但它似乎不起作用.例如

import com.fasterxml.jackson.annotation.JsonProperty;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

public class SimpleFooRequest {

    @NotNull
    @JsonProperty(value = "count")
    @Min(value = 100,message = "must be min 10")
    private  Integer count;

    @NotNull
    private String name;
    public String getName() {return name; }
    public void setName(String name) { this.name = name; }
    public Integer getCount() {return count;}
    public void setCount(Integer count) {this.count = count;}
}

当试图解散json时

@Test
public void testFooRequest() throws Exception
{
  String fooJson = {"count":-10}
  ObjectMapper mapper = new ObjectMapper()
  SimpleFooRequest request = mapper.readValue(fooJson,SimpleFooRequest.class);
  assert …

我正在使用 scala 编写一些测试到 java maven 项目。我想使用 Maven 插件运行这些测试，但我还希望其余的 JUnit 测试也能运行。问题是，根据本指南， 我必须禁用 Surefire 。我有一个同时运行 scalatest 和 junit 测试的解决方案吗？

我有几个类都扩展了相同的特性,并且共享了应该改变其状态的相互功能.但是我想知道是否有更好的方法来实现相同的功能.

例如:

trait Breed
case object Pincher extends Breed
case object Haski extends Breed

trait Foox{
  def age: Int
  def addToAge(i: Int): Foox 
}

case class Dog(breed: Breed, age: Int) extends Foox
case class Person(name: String, age: Int) extends Foox

我希望addToAge它将返回与附加int相同的对象,当然我可以为每个类实现相同的,这与DRY规则相矛盾:

case class Dog(breed: Breed, age: Int) extends Foox{
  def addToAge(i: Int) = copy(age = age + i)
}
case class Person(name: String, age: Int) extends Foox{
  def addToAge(i:Int) = copy(age = age + i)
}

1. 有没有更好的方法来避免这种情况？

2. 是否有一个选项可以避免重新定义该年龄:在每个案例类中使用Int并保持其状态(年龄已经在特征中定义)？

我刚开始使用 elasticsearch 5.2 。

如果我有以下映射，我正在尝试获取索引中的所有键：

"properties": {
         "name": { "type": "text" },
         "article": {
          "properties": {
           "id": { "type": "text" },
           "title":  { "type": "text"},
           "abstract": { "type": "text"},
            "author": {
             "properties": {
              "id": { "type": "text" },
              "name": { "type": "text" }
}}}} } }

是否可以获取所有字段的全名？ 像这样：

 name,
 article.id ,
 article.title ,
 article.abstract ,
 article.author.id,
 article.author.name

我怎么能得到呢？

假设我有这个ADT:

case class Person(id: String)
case class Kid(id: String, name: String)

我想以更明确和类型安全的方式表示id字段.我有两个选择

1.输入别名

type PersonId = String
case class Person(id: PersonId)
case class Kid(id: String, name: PersonId)

价值等级

case class PersonId(id: String) extends AnyVal
case class Person(id: PersonId)
case class Kid(id: String, name: PersonId)

哪种方法比较惯用？在这种情况下使用值类是否有任何优点(没有其他方法)？

看这篇文章，它说关于水印

现在，我们将水印设置为当前时间 - 5 秒，这告诉 Flink 期望消息最多处理 5 秒 - 这是因为只有当水印通过每个窗口时才会评估它

在那篇文章的后面，它解释了设置允许迟到时：

Flink 不会丢弃消息，除非它超过了 window_end_time + 允许的延迟

由于设置了允许的延迟，实际上导致了窗口的延迟评估？

那么水印的使用和允许迟到实际上有什么区别？什么时候使用哪个？

试图理解为什么以下表达式产生Future [Nothing]而不是Future [List [Int]]

def foo(): Future[List[Int]] = Future(List(1,2,3,3,3,4,4,4))
def bar(): Future[Nothing] =for {
    fooList <- foo()
    f <- fooList.distinct
} yield f

当然,这是简化的例子,我可以直接返回fooList.但我试图了解获得Future[Nothing]和不获得的原因Future[List[Int]]