小编Bru*_*son的帖子

我希望能够找到一个单词的第一个字母和一个组中的一个字母(如"ABC")之间的匹配.在伪代码中,这可能看起来像:

case Process(word) =>
   word.firstLetter match {
      case([a-c][A-C]) =>
      case _ =>
   }
}

但是我如何抓住Scala中的第一个字母而不是Java呢？如何正确表达正则表达式？是否可以在案例类中执行此操作？

好吧,这可能是一个相当愚蠢的问题,但在actor框架中使用并行集合有什么好处？也就是说,如果我一次只从一个演员的邮箱处理一条消息,那么是否需要并行收集？并行集合和参与者是否相互排斥？什么是涉及两者的用例？

我正在尝试创建一个具有键映射 - >函数调用的类,并且以下代码的行为与我希望的不同.

class MyClass {
    val rnd = scala.util.Random

    def method1():Double = {
        rnd.nextDouble
    }

    def method2():Double = {
        rnd.nextDouble
    }

    def method3():Double = {
        rnd.nextDouble
    }

    def method4():Double = {
        rnd.nextDouble
    }

    def method5():Double = {
        rnd.nextDouble
    }

    var m = Map[String,Double]()    
    m += {"key1"-> method1}
    m += {"key2"-> method2}
    m += {"key3"-> method3}
    m += {"key4"-> method4}
    m += {"key5"-> method5}

    def computeValues(keyList:List[String]):Map[String,Double] = {
        var map = Map[String,Double]()
        keyList.foreach(factor => {
            val value = m(factor)
            map …

迭代地图并过滤掉某些键的最佳方法是什么？伪代码可能是这样的

    map.foreach(tuple where !list.contains(tuple._1) => { })

谢谢布鲁斯

在Java中,我可以执行以下操作:

TreeMap<Double, String> myMap = new TreeMap<Double, String>();

如果我希望它以相反的顺序排序,我可以提供一个比较器,例如:

class ReverseOrder implements Comparator<Object> {

    public ReverseOrder() {

    }

    public int compare(Object o1,Object o2) {
        Double i1=(Double)o1;
        Double i2=(Double)o2;
        return -i1.compareTo(i2);
    }
}

并将对象实例化为

TreeMap<Double, MyObject> myMap = new TreeMap<Double, MyObject>()(new ReverseOrder());

如果我想从Scala中创建可变的Java TreeMap,我可以这样做:

var treeMap = new java.util.TreeMap[Double,MyObject]

如何在Scala中实现Java比较器,以便我可以根据升序或降序进行排序？在这里,我假设我不能将Scala Ordering特征与Java集合混合.另外,有没有人知道Scala中是否可以使用可变的TreeMap？

我希望能够将类似数组的结构增长到最大尺寸,之后每次添加新元素时,最旧的(第一个)元素将从结构中删除.我不知道最好的方法是什么,但一种方法是扩展ArrayBuffer类,并覆盖+ =运算符,这样如果达到最大大小,每次新的时候都会删除第一个元素一个是添加.我还没想出如何正确扩展集合.到目前为止我所拥有的是:

class FiniteGrowableArray[A](maxLength:Int) extends scala.collection.mutable.ArrayBuffer {
    override def +=(elem:A): <insert some return type here> = {
        // append element
        if(length > maxLength) remove(0)
        <returned collection>
    }
}

有人可以建议一条更好的道路和/或帮助我吗？注意:我需要在+ =操作之间多次任意访问结构中的元素.

谢谢

在Akka或Scala Actor中进行模式匹配时,有没有办法看到匹配不是什么(即)通配符_正在评估什么？有没有一种简单的方法可以查看从邮箱中处理哪条消息无法找到匹配项？

def receive = {
  case A =>
  case B =>
  case C =>
  ...
  case _ =>
    println("what IS the message evaluated?")
}

谢谢,

布鲁斯

我有一个场景,我有一些对象需要互相参考.我可以编译的唯一方法是使用lazy

class A(b:B)
class B(a:A)
lazy val a:A = new A(b)
lazy val b:B = new B(a)

我可以使用一些演员做同样的事情,并让它也编译

    abstract class Message
    case class Message1 extends Message
    case class Message2 extends Message

    class Actor1(otherActor:Actor) extends Actor {
        def act() {
            loop {
                react {
                    case Message1 =>
                        println("received message1")
                        otherActor ! Message2
                    case _ =>
                }
            }
        }
    }

    class Actor2(otherActor:Actor) extends Actor {
        def act() {
            loop {
                react {
                    case Message2 =>
                        println("received message2")
                        otherActor ! Message1
                    case …

如果我有以下代码:

var A = Array[Array[Double]]()    // where A becomes an MxP matrix
var B = Array[Array[Double]]()    // where B becomes an NxP matrix

什么是一个有效的方法将一个矩阵附加到另一个矩阵,导致单个矩阵,如下面的伪代码所示？

val C = A append B    // where C is a (M+N)xP matrix

显然,其中一个维度(在这种情况下为P)保持不变.

编辑:到目前为止,两个提供的解决方案都在第二个方面增长.我试图修复第二个维度.

我想根据该实例外部的信息有条件地创建对象实例的副本.副本中的大多数信息将与原始信息相同,但某些信息需要更改.这些信息是在actor之间传递的,所以我需要对象是不可变的,以避免奇怪的并发相关行为.以下玩具代码是我想要帮助的一个简单示例.

如果我有以下代码:

case class Container(condition:String,amount:Int,ID:Long)

我可以做以下事情:

    val a = new Container("Hello",10,1234567890)
    println("a = " + a)
    val b = a.copy(amount = -5)
    println("b = " + b)
    println("amount in b is " + b.amount)

而输出是

a = Container(Hello,10,1234567890)
b = Container(Hello,-5,1234567890)
amount in b is -5

我还可以有条件地创建对象的副本,执行以下操作:

import scala.Math._
val max = 3     
val c = if(abs(b.amount) >= max) b.copy(amount = max,condition="Goodbye") else if(abs(b.amount) < max) b.copy(amount = abs(b.amount))
println("c = " + c)

如果我将b对象中的数量设置为-5,则输出为

c = Container(Goodbye,3,1234567890)

如果我将b对象中的数量设置为-2,则输出为

c …