小编bin*_*ADa的帖子

使用Scala 2.9实现一种Dijkstra算法(伪代码)

val queue = new PriorityQueue
queue.insert(...)
while (!queue.isEmpty) {
  val u = queue.extractMin
  queue.foreach { v =>
    if (condition(u, v))
      queue.decreaseKey(v, newPriority)
  }
}

我想改变Scala中项目的优先级collection.mutable.PriorityQueue.

因此试图

• 除去项目
• 改变优先权
• 重新插入队列.

但是我找不到一种方法来更新优先级或删除特定项目(不一定是头元素),就像从优先级队列java.util.PriorityQueue#remove(Object)中 删除项目一样.

• 如何完成此任务scala.collection.mutable.PriorityQueue 或者我必须使用java.util.PriorityQueue？

• 有没有人知道这种方法是否缺乏设计,并且建议在更改某些项目的优先级后重建队列(可能需要查看有关优先级队列与动态项目优先级的讨论)？

偶然发现了

def foo(f: Int => Unit) {}
def foo(f: Long => Unit) {}

由于没有编译method foo is defined twice.我知道上面只是一个简写

def foo(f: Function1[Int, Unit]) {}
def foo(f: Function1[Long, Unit]) {}

并且在类型擦除之后,两种方法都具有相同的签名.

现在我已经阅读了在2.8.0 RC1中尝试专用的Function1/Function2!这Function1和Function2拥有@specialized的版本Int,Long并Double在Scala 2.8.这无疑意味着,Function[Int, Unit]并且Function[Long, Unit]有独立的类文件在JVM的水平.

那么两个签名都不会有所不同吗？

问题是,第二种类型的参数会继续被删除吗？但同样的问题

class Bar[@specialized T]
def foo(f: Bar[Int]) {}
def foo(f: Bar[Long]) {}

它没有编译.

我想打印持续时间,以毫秒为单位,具有不同的格式规范,具体取决于其大小:

case (1)      "H:mm"  if duration < 10 hours
case (2)     "HH:mm"  if duration < 24 hours
case (3)  "#d HH:mm"  else (duration >= 24 hours)

这意味着只有1小时的字段数字,持续时间低于10小时,
但有一个领先的日期字段时有2小时的字段数字!

例子:

case (1)      "0:45"  means 45 minutes,
              "1:23"  means 1 hour and 23 minutes,
case (2)     "12:05"  means 12 hours and 5 minutes and
case (3)  "1d 05:09"  means 1 day, 5 hours and 9 minutes
                               (= 29 hours and 9 minutes).

我试过了

object JodaTest {
  import org.joda.time._
  private val pdf = …

在创建Scala文档时,我还使用了这里记录的@throws和@note标签(Scaladoc Wiki - Tags and Annotations).

不幸的是我在生成的Scaladoc中找不到这些.

是否必须设置某些开关,考虑具体的事情或这是一个已知的问题？

顺便说一句:使用Scala 2.9.0.1 的scaladoc Ant任务也没有发出警告.

编辑: BTW2并澄清:我不是指@throws注释

@throws(classOf[RuntimeException])
def dispatch: Nothing = throw new RuntimeException

这是在注释部分记录的,def但@throwsScaladoc 的标签就像

/** @throws RuntimeException
 */
def dispatch: Nothing = throw new RuntimeException

我想在序列中聚合兼容元素,即将a转换Seq[T]为Seq[Seq[T]]每个子序列中的元素彼此兼容的同时保留原始seq顺序,例如从

case class X(i: Int, n: Int) {
  def canJoin(that: X): Boolean = this.n == that.n
  override val toString = i + "." + n
}
val xs = Seq(X(1, 1), X(2, 3), X(3, 3), X(4, 3), X(5, 1), X(6, 2), X(7, 2), X(8, 1))
/* xs = List(1.1, 2.3, 3.3, 4.3, 5.1, 6.2, 7.2, 8.1) */

想得到

val js = join(xs)
/* js = List(List(1.1), List(2.3, 3.3, 4.3), List(5.1), List(6.2, 7.2), List(8.1)) */

我试图以功能的方式做到这一点,但我中途陷入困境:

做一个while循环 …

我必须处理订单序列(这里是Int为了简化):

// the handleOrder methods are in fact much more complicated:
def handleOrders(prev: Double, orders: Seq[Int]): Double = prev + orders.sum
def handleOrder(prev: Double, order: Int): Double = prev / order

由于所谓的结果

def nextGroup(prev: Double, orders: Seq[Int]): Seq[Double]

function我得到另一个类的序列(这里是Double为了简化).

由此我实现了两个版本.

版本1(foldLeft和显式构建器):

def nextGroup1(prev: Double, orders: Seq[Int]): Seq[Double] = {
  import collection.mutable.Builder
  import collection.immutable.VectorBuilder
  val bld: Builder[Double, Seq[Double]] = new VectorBuilder[Double]
  var first = true
  orders.foldLeft(prev) { (prev, order) =>
    val step = if (first) handleOrders(prev, orders) …