小编Lui*_*hys的帖子

是否可以创建一个具有对合作伙伴对象的不可变引用的类,或者它是否必须是var我在创建后分配的类？

例如

class PairedObject (p: PairedObject, id: String) {
  val partner: PairedObject = p  // but I need ref to this object to create p!
}

或类似地,我如何实例化以下对？

class Chicken (e: Egg) { 
  val offspring = e
}

class Egg (c: Chicken) {
  val mother = c
}

我正在寻找关于项目欧拉的问题三十一,请问,有多少不同的方法可以使用任意数量的1p,2p,5p,10p,20p,50p,£1(100p)和£的硬币赚2英镑2(200p).

有递归解决方案,例如Scala中的这个解决方案(由Pavel Fatin提供)

def f(ms: List[Int], n: Int): Int = ms match {
  case h :: t =>
    if (h > n) 0 else if (n == h) 1 else f(ms, n - h) + f(t, n)
  case _ => 0
} 
val r = f(List(1, 2, 5, 10, 20, 50, 100, 200), 200)

虽然运行速度足够快,但它的效率相对较低,调用f函数大约560万次.

我看到了其他用Java编写的动态编程解决方案(来自葡萄牙的wizeman)

final static int TOTAL = 200;

public static void main(String[] args) {
    int[] coins = {1, 2, 5, 10, 20, …

Scala中是否有新行字符的简写？在Java(在Windows上)我通常只使用"\n",但这似乎在Scala中不起作用 - 特别是

val s = """abcd
efg"""
val s2 = s.replace("\n", "")
println(s2)

输出

abcd
efg

在Eclipse中,

efgd

(原文如此)来自命令行,和

abcdefg

来自REPL(伟大的成功!)

String.format("%n") 有效,但还有什么更短的吗？

在集合映射中查找结果的习惯用法如下:

list.view.map(f).find(p)

其中list是一个List[A],f是一个A => B,并且p是一个B => Boolean.

是否可以使用view并行集合？我问,因为我得到一些非常奇怪的结果:

Welcome to Scala version 2.9.1.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0).
Type in expressions to have them evaluated.
Type :help for more information.

scala> val f : Int => Int = i => {println(i); i + 10}
f: Int => Int = <function1>

scala> val list = (1 to 10).toList
list: List[Int] = List(1, 2, 3, 4, …

假设我们想要创建一个像minBy这样的函数返回集合中所有相同极简主义的元素:

def multiMinBy[A, B: Ordering](xs: Traversable[A])(f: A => B) = {
  val minVal = f(xs minBy f)
  xs filter (f(_) == minVal)
}

scala> multiMinBy(List("zza","zzza","zzb","zzzb"))(_.last)
res33: Traversable[java.lang.String] = List(zza, zzza)

到目前为止,这么好,除了我们有一个Traversable后退而不是我们的初始List.

所以我尝试将签名更改为

def multiMinBy[A, B: Ordering, C <: Traversable[A]](xs: C)(f: A => B)

希望我可能得到一个C回来而不是一个Traversable[A].但是,我没有得到任何回报:

scala> multiMinBy(List("zza","zzza","zzb","zzzb"))(_.last)

<console>:9: error: inferred type arguments [Nothing,Nothing,List[java.lang.String]] 
do not conform to method multiMinBy's type parameter bounds [A,B,C <: Traversable[A]]

我认为这是因为我们C之前A已经推断出论证？所以我翻转了参数的顺序,并添加了一个演员:

def …

有很多关于从Scala代码调用Java varargs的文章,但我唯一能找到相反的方法就是这个问题:在java中使用scala vararg方法,它没有任何具体的例子.

我试图使用scala.Console一些Java代码,因为它java.io.Console在Eclipse中不起作用,而Scala则起作用.但我无法得到这种方法

def readLine (text: String, args: Any*): String

工作,因为它似乎期待scala.collection.Seq[Any]第二个参数,我不知道如何Seq在Java中创建 .我该如何解决这个问题？

我试过的事情:

1)使用null

// Java
String s = scala.Console.readLine("Enter text: ", null);

- 获得奖励NullPointerException.

2)替换nullwith scala.collection.Seq.empty(),但javac会报告各种错误,例如Seq没有empty方法.

3)Nil在scala.collection.immutable包对象中使用对象,但是这里建议的语法是scala.collection.immutable.package$Nil$.MODULE$,但是无法解决.

当然我可以使用readLine()不采用varargs 的方法,但这太容易了.

我想将一个字符串拆分为交替的单词.总会有一个偶数.

例如

val text = "this here is a test sentence"

应该转换为包含的某些有序集合类型

"this", "is", "test"

和

"here", "a", "sentence"

我想出来了

val (l1, l2) = text.split(" ").zipWithIndex.partition(_._2 % 2 == 0) match {
  case (a,b) => (a.map(_._1), b.map(_._1))}

这给了我两个数组的正确结果.

这可以更优雅地完成吗？

我已经比较了scala版本

(BigInt(1) to BigInt(50000)).reduce(_ * _)

到python版本

reduce(lambda x,y: x*y, range(1,50000))

事实证明,scala版本比python版本长了大约10倍.

我猜,一个很大的区别是python可以使用其原生long类型而不是为每个数字创建新的BigInt对象.但scala中有解决方法吗？

看看这个问题,提问者对a中某个元素的第一个和最后一个实例感兴趣List,似乎更有效的解决方案是使用DoubleLinkedList可以从列表末尾向后搜索的问题.但是,集合API中只有一个实现,它是可变的.

为什么没有不可变版本？

以下两个都是为了创建一个整数流:

val s: Stream[Int] = 1 #:: s.map(_ + 1)

def makeStream = {
  val s: Stream[Int] = 1 #:: s.map(_ + 1)
  s
}

第一个很好; 但是该makeStream方法不会编译:

error: forward reference extends over definition of value s
  val s: Stream[Int] = 1 #:: s.map(_ + 1)
                             ^

它只会编译,如果我们做s一个lazy val.为什么它需要lazy val在一个方法中,但不在外面？