小编oxb*_*kes的帖子

在将泛型引入Java语言之前,我会编写封装集合集合的类.例如:

class Account {
   private Map tradesByRegion; //KEY=Region, VALUE=TradeCollection
}

class TradeCollection {
   private Map tradesByInstrument; //KEY=Instrument, Value=Trade
}

当然,对于泛型,我可以这样做:

class Account {
   private Map<Region, Map<Instrument, Trade>> trades;
}

我现在倾向于选择选项#2(在选项#1的通用版本上),因为这意味着我最终不会出现仅仅为了包装集合而存在的类的扩散.但我有一种唠叨的感觉,这是糟糕的设计(例如,在声明新类之前我应该​​使用多少嵌套集合).意见？

我试图抓住一个鼠标点击即可Table(这应该会导致弹出窗口显示).桌子位于a ScrollPane里面(反过来)Panel.我已经添加了对所有类的反应,但我似乎永远不会真正得到一个点击事件被捕获!

class MyPanel extends GridBagPanel {
  val gbc = new GridBagContraints( ... )

  add(new ScrollPane {
    reactions += {
      case MouseClicked(src, point, mod, clicks, pops) =>
        println("Scroll pops: " + pops)
    } 

    viewportView = new Table {
      reactions += {
        case MouseClicked(src, point, mod, clicks, pops) =>
          println("Table pops: " + pops)
      } 

      ...
    }

  }, gbc)

  reactions += {
    case MouseClicked(src, point, mod, clicks, pops) =>
      println("Panel pops: " + pops)
  } 
} …

我有一个相当标准的Java机制来解决这个问题:

• 必须安排工作项在特定时间执行
• 然后,每个工作项必须等待条件成为真
• 工作项应该可以取消

我使用的解决方案如下:

1. 有一个单线程调度程序来安排我的工作项
2. 有一个ExecutorService(可能是多线程的)
3. 然后,每个计划的工作项将实际工作提交给ExecutorService.返回的Future内容缓存在地图中.完成服务用于在工作完成时从缓存中删除未来
4. 可以通过缓存的期货取消商品

当然,我的执行者需要至少与我期望的阻塞工作项的数量一样大,但这在实践中不是问题.

所以现在我在Scala中编码并使用actor框架.假设我的工作项可以封装在发送给actor的事件中:

1. 我将使用什么机制来安排特定时间的工作项？
2. 如果工作项是发送给actor的事件,我如何确保支持线程池大于可以同时阻塞的项的数量
3. 如何取消之前安排的工作项？

我打电话的时候:

actor_ ! Exit

如何将其转换为以下结构:

case class Exit(from: AbstractActor, reason: AnyRef)

特别地,它是如何,当我把这种从已经远程(客户端)演员link编到远程(服务器)演员,该服务器接收的一个实例Exit,其中from属性是一个演员:

'remotesender0@Node(10.10.7.90,8366)

基本上我想知道如何获得这个remote-client-actor对象的句柄!

我现在用scala actor编写了一些应用程序,我对人们如何处理或处理我遇到的一些问题感兴趣.

过多的Message类或!？

我有一个演员,它会对用户操作作出反应并且必须导致某些事情发生.让我们说react一个消息UserRequestsX(id).我遇到的一个问题是,因为我想模块化我的程序,单个演员本身无法在不涉及其他演员的情况下完成动作.例如,假设我需要使用id参数来检索一堆值,然后需要通过其他一些actor删除它们.如果我正在编写一个普通的Java程序,我可能会这样做:

public void reportTrades(Date date) {
    Set<Trade> trades = persistence.lookup(date);
    reportService.report(trades);
}

这很简单.然而,使用演员这会变得有点痛苦,因为我想避免使用 !?.一个参与者对ReportTrades(date)消息做出反应,但它必须要求PersistenceActor交易然后ReportActor报告它们.我发现这样做的唯一方法是:

react {
    case ReportTrades(date) =>
       persistenceActor ! GetTradesAndReport(date)
}

所以,在我PersistenceActor的反应块中:

react {
    case GetTradesAndReport(date) =>
       val ts = trades.get(date) //from persietent store
       reportActor ! ReportTrades(ts)
}

但现在我有两个问题:

1. 我必须创建额外的消息类来表示相同的请求(即"报告交易").事实上,我在这种情况下有三个,但我可能还有更多 - 这成为跟踪这些问题的一个问题
2. 我该怎么称呼第一条和第三条消息ReportTrades？把它们都称之为令人困惑ReportTrades(或者如果我这样做,我必须将它们放在单独的包中).本质上说是因为没有这样的事情overloading一类val的类型.

有什么我想念的吗？我可以避免这个吗？我应该放弃并使用!?人们是否使用某种组织结构来澄清发生了什么？

我有以下问题:我有一个函数,它以List [Double]作为参数,对列表的元素执行一些算术运算,然后返回结果.我希望该函数也接受List [Int].这是一个例子:

def f(l: List[Double]) = {
    var s = 0.0 
    for (i <- l)
        s += i
    s
}

val l1 = List(1.0, 2.0, 3.0)
val l2 = List(1, 2, 3)

println(f(l1))
println(f(l2))

当然第二个println失败,因为f需要List [Double]而不是List [Int].

还要注意f函数中和的非scala样式公式,以证明需要在函数本身内使用0(或其他常量)(如果我将Int值与init s s相加而不是0.0.

哪个是使函数在Double和Int上运行的最佳方法(更少的代码)？

(我已经看到一些关于2.8数字特性的东西,我不太确定如何使用它......)

谢谢大家的帮助.

当我正在思考在以下情况下发生的事情的时候,我只是对托尼·莫里斯对猫咪的优秀演习进行了喋喋不休的讨论 ......

def cata[X](some: A => X, none: => X): X

现在让我称这个方法如下:

def isDefined: Boolean = cata( _ => true, false)

我想知道的类型是否inferencer确定的类型的_ => true要A => Boolean或Any => Boolean.由于输入参数Function1是反变量的事实,以下两个编译都很好:

def isDefined: Boolean = cata( (_: A) => true, false)    //#1
def isDefined: Boolean = cata( (_: Any) => true, false)  //#2

所以问题是,类型推断器是出现#1还是#2？

假设我有

type VS[A] = Validation[String, A]

val v: VS[Option[A]]
val f: A => VS[B]

我想获得类型的结果,VS[Option[B]]但如果v是a Success(None),结果也应该是a Success(None).这是一个例子:

scala> val v: VS[Option[String]] = some("4.5").success
v: VS[Option[String]] = Success(Some(4.5))

scala> val f = (s : String) => (try { s.toInt.success } catch { case x => x.getMessage.fail }): VS[Int]
f: String => VS[Int] = <function1>

然后:

scala> import Validation.Monad._
import Validation.Monad._

scala> (v map2 f map (_.sequence)).join
res4: scalaz.Validation[String,Option[Int]] = Failure(For input string: "4.5")

成功案例是:

scala> …

如果我有方法......

def arrayConformsTo[A](as: Array[_]) = ???

......在那里我可以添加上下文边界到A需要.我希望这个方法看看它的组件类型,Array如果这是一个子类型,则返回true A.所以,例如:

arrayConformsTo[Int](Array(1, 2, 3)) //returns true

arrayConformsTo[String](Array(1, 2, 3)) //returns false

在2.10之前,这将完成如下:

def arrayConformsTo[A: Manifest](as: Array[_]) = 
  ClassManifest.fromClass(as.getClass.getComponentType) <:< manifest[A]

但是,这现在编译了弃用警告

<console>:8: warning: method <:< in trait ClassManifestDeprecatedApis is deprecated: Use scala.reflect.runtime.universe.TypeTag for subtype checking instead
       ClassManifest.fromClass(as.getClass.getComponentType) <:< manifest[A]
                                                         ^
<console>:8: warning: value ClassManifest in object Predef is deprecated: Use scala.reflect.ClassTag instead
       ClassManifest.fromClass(as.getClass.getComponentType) <:< manifest[A]

我对此的第一个猜测如下:

scala> def arrayConformsTo[A: reflect.ClassTag](as: Array[_]) =
     | reflect.ClassTag(as.getClass.getComponentType) <:< implicitly[reflect.ClassTag[A]] …

我有一些不是线程安全的类:

class ThreadUnsafeClass {
  long i;

  long incrementAndGet() { return ++i; }
}

(我在long这里使用了a 作为字段,但我们应该将其字段视为一些线程不安全的类型).

我现在有一个看起来像这样的课程

class Foo {
  final ThreadUnsafeClass c;

  Foo(ThreadUnsafeClass c) {
    this.c = c;
  }
}

也就是说,线程不安全类是它的最后一个字段.现在我要这样做:

public class JavaMM {
  public static void main(String[] args) {
    final ForkJoinTask<ThreadUnsafeClass> work = ForkJoinTask.adapt(() -> {
      ThreadUnsafeClass t = new ThreadUnsafeClass();
      t.incrementAndGet();
      return new FC(t);
    });

    assert (work.fork().join().c.i == 1); 
  }
}

也就是说,从thread T(main),我调用了一些工作T'(fork-join-pool),它创建并改变了我的不安全类的实例,然后返回包含在a中的结果Foo.请注意,我的线程不安全类的所有变异都发生在一个线程上T'.

问题1:我是否保证thread-unsafe-class实例的结束状态安全地移植到？的 …