标签: scala-collections

有没有理由为什么Scala中没有隐式的列表排序？

val lists = List(List(2, 3, 1), List(2, 1, 3))
lists.sorted

error: could not find implicit value for parameter ord: Ordering[List[Int]]

编辑

是的,我的问题是为什么没有内置订购已隐含在范围内.对我来说,似乎显而易见的是,第二个列表应该"小于"第一个列表,因为0处的项目相等而第二个列表的较低项目为1.我想知道是否可能是因为没有好的答案列表有两种不同的尺寸.

Scala集合中是否提供循环队列？

我需要重复迭代一个循环自己的列表

val x = new CircularList(1,2,3,4)
x.next (returns 1)
x.next (returns 2)
x.next (returns 3)
x.next (returns 4)
x.next (returns 1)
x.next (returns 2)
x.next (returns 3)

... 等等

假设你有一个List(1,"1")它是类型List [Any],这当然是正确的和预期的.现在,如果我像这样映射列表

scala> List(1, "1") map {
     |   case x: Int => x
     |   case y: String => y.toInt
     | }

结果类型是List [Int],也是预期的.我的问题是,是否存在等效于过滤器的映射,因为以下示例将导致List [Any].这可能吗？我假设这可以在编译时解决,可能不是运行时？

scala> List(1, "1") filter {
     |   case x: Int => true
     |   case _ => false
     | }

我知道Traversable,你需要一个foreach方法.Iterable需要一种iterator方法.

Scala 2.8集合SID和"与类型战斗的Bitrot"论文基本上都没有提到为什么Traversable被添加.SID只说"David McIver ......将Traversable提议为Iterable的概括".

我从IRC的讨论中模糊地收集到,当收集的遍历终止时,它与回收资源有关吗？

以下内容可能与我的问题有关.有一些奇怪的函数定义TraversableLike.scala,例如:

def isEmpty: Boolean = {
  var result = true
  breakable {
    for (x <- this) {
      result = false
      break
    }
  }
  result
}

我认为有一个很好的理由不仅仅是作为:

def isEmpty: Boolean = {
  for (x <- this)
    return false
  true
}

每次调用一个函数时,如果给定的一组参数值的结果尚未被记忆,我想将结果放入内存表中.一列用于存储结果,另一列用于存储参数值.

我该如何最好地实现这一点？争论的种类繁多,包括一些枚举.

在C#中,我通常使用DataTable.Scala中有同等的东西吗？

我正在通过Cay Horstmann的Scala for the Impatient book,我遇到了这种更新可变地图的方式.

scala> val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores: scala.collection.mutable.Map[String,Int] = Map(Bob -> 3, Alice -> 10, Cindy -> 8)

scala> scores("Alice") // retrieve the value of type Int
res2: Int = 10

scala> scores("Alice") = 5 // Update the Alice value to 5

scala> scores("Alice")
res4: Int = 5

它看起来像scores("Alice")命中apply在MapLike.scala.但这只返回值,而不是可以更新的值.

出于好奇,我在不可变的地图上尝试了相同的语法,并出现以下错误,

scala> val immutableScores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" …

例如,对于任何给定的集合,

val fruits = Set("apple", "grape", "pear", "banana")

如何从中获取随机元素fruits？

非常感谢.

这似乎可以使用Java 7和任何版本的Scala库进行编译:

public static void main(String[] args) {
    scala.collection.immutable.Set<String> set = new scala.collection.immutable.HashSet<String>();
    Iterator<String> iterator = set.iterator();
}

它还可以编译Java 8和Scala 2.11.5+.但是使用Java 8和Scala 2.11.4,Eclipse抱怨:

The method iterator() is ambiguous for the type Set<String>

我不明白这一点.您可能会对在某些上下文中选择哪个重载方法感到不明确,但如果您没有传递任何参数,肯定不会？

真奇怪的是,如果我像这样重铸:

public static void main(String[] args) {
    Iterator<String> iterator = new scala.collection.immutable.HashSet<String>().iterator();
}

投诉消失了.在我看来,这与上面的版本完全相同.那为什么它现在编译好了？

我想知道在哪些情况下哪些数据结构最适合使用"包含"或"存在"检查.

我问,因为我来自Python背景,并习惯于使用if x in something:表达式.例如,哪些表达式评估最快:

val m = Map(1 -> 1, 2 -> 2, 3 -> 3, 4 -> 4)
                                          //> m  : scala.collection.immutable.Map[Int,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3, 4
                                          //|  -> 4)
val l = List(1,2,3,4)                     //> l  : List[Int] = List(1, 2, 3, 4)
val v = Vector(1,2,3,4)                   //> v  : scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4)

m.exists(_._1 == 3)                       //> res0: Boolean = true
m.contains(3)                             //> res1: Boolean = true …

我正在将我的Java代码库迁移到纯Scala,我仍然坚持使用这一段代码.我有一个让我们的IntervalMap即数据结构的实现你有效地映射范围[from,to]到values了哪里set,delete和get操作都O(log n)(从IntervalTree或线段树略有不同).

这段代码使用Java java.util.TreeMaps,在迁移到Scala时,我遇到了两个大问题:

1. Scala没有mutable.TreeMap- 我决定通过使用mutable.TreeSet(奇怪的是Scala mutable.TreeSet但没有mutable.TreeMap)来存储密钥并将值存储在辅助中mutable.Map.这是一个不愉快的黑客,但还有更好的方法吗？

2. 接下来的问题是Scala的mutable.TreeSet没有类似的java.util.TreeSet的ceilingKey,floorEntry,pollFirst,pollLast这些都是O(log n)在Java操作.

那么,我怎样才能最好地将我的代码迁移到Scala？这些情况下的最佳做法是什么？我真的不想编写自己的树实现.有没有更惯用的Scala编写IntervalMaps的方式,我不知道？或者那里有一些有信誉的图书馆？或者Scala只是简单地用它的gimped TreeSet和不存在的TreeMaps来吸吮.当然,我可以TreeMap在Scala中使用Java ,但这很丑陋,我失去了所有不错的Scala集合功能,我不妨使用Java.

这是我目前的Java代码:https://gist.github.com/pathikrit/5574521