小编Chr*_*ris的帖子

作为Scala(2.9.1)的新手,我有一个List[Event]并希望将其复制到一个Queue[Event],但是下面的语法产生了一个Queue[List[Event]]代替:

val eventQueue = Queue(events)

出于某种原因,以下工作:

val eventQueue = Queue(events : _*)

但我想了解它的作用,以及它的工作原理？我已经看过Queue.apply函数的签名了:

def apply[A](elems: A*)

我理解为什么第一次尝试不起作用,但第二次尝试的含义是什么？什么是:,_*在这种情况下,为什么apply功能只是采取Iterable[A]？

可能重复:
计数与集合中的长度与大小

真奇怪:

C#数组如下

double[] test = new double[1];

支持Length属性以获取数组的大小.但是数组也实现了IList接口:

IList<double> list = test;

但是,IList接口还提供Count属性.为什么阵列(在这种情况下为"测试")没有？

编辑:感谢所有人,他们指出它实际上是提供Count属性的ICollection接口(不是IList),而且这也是由于接口的显式实现.

Scala中2.11.2,下面的最小例如使用当仅编译类型归属于Array[String]:

object Foo {    

  def fromList(list: List[String]): Foo = new Foo(list.toArray : Array[String])   

}

class Foo(source: IndexedSeq[String])    

如果我删除类型ascription in fromList,它将无法编译,并出现以下错误:

Error:(48, 56) polymorphic expression cannot be instantiated to expected type;
 found   : [B >: String]Array[B]
 required: IndexedSeq[String]
  def fromList(list: List[String]): Foo = new Foo(list.toArray)
                                                       ^

为什么编译器不能在Array[String]这里推断？或者这个问题是否必须对从Arrays到IndexedSeqs 的隐式转换做些什么呢？

在 JVM 上，两个双精度值之间的除法是否总是产生与整数除法相同的精确结果？

具有以下先决条件：

• 除法无余数
• 不除以零
• x和实际上都y保存整数值。

例如在下面的代码中

double x = ...;
int resultInt = ...;
double y = x * resultInt;
double resultDouble = y / x; // double division

总是resultDouble相等resultInt还是可能会有一些精度损失？

在想知道我的第一个Scala应用程序中的某些错误后,我发现我的限制功能根本不起作用......

所以这是我的第一次尝试:

  def limit(x : Double, min: Double, max : Double) = {
    if (x < min) min;
    if (x > max) max;
    x;
  }

它总是回来x!

我的第二次尝试看起来像这样:

  def limit(x : Double, min: Double, max : Double) : Double = {
    if (x < min) return min;
    if (x > max) return max;
    x;
  }

它起作用了.

所以我的问题:为什么是min;和max;第一个示例基本无操作,并且x;是不？我的第二次尝试是好Scala吗？

在下面的示例代码中,为什么Iterable [String] test1在映射后生成一个Set？

val foo = Map("a" -> 1, "b" -> 1)
val test1: Iterable[String] = foo.keys
val test2: Iterator[String] = foo.keys.toIterator

println(test1.map(foo).size) // 1
println(test2.map(foo).size) // 2

我对此感到困惑,因为在阅读代码时它完全违反直觉.即使foo.keys只返回一个Iterable,它也会在调用时创建一个Set map,如反射代码所示:

println(test1.map(foo).getClass.getName) // immutable.Set.Set1
println(test2.map(foo).getClass.getName) // Iterator$$anon$11

标准库如何确定它应该在immutable.Set这里创建一个,即使该集合的推断类型只是Iterable[String]？