小编oxb*_*kes的帖子

我有一个Java BigInteger类的问题:我无法将大值粘贴到BigInteger中.例如,假设我想为此数字指定一个BigInteger:

26525285981219105863630848482795

我无法直接分配它,因为编译器认为它是一个整数:

val bi = 26525285981219105863630848482795 //compile error

但我希望它是一个BigInteger.有没有办法可以直接将其粘贴到源代码中？如果没有这种方式,那么在Scala中是否有一种方法,它有一个更容易使用的BigInt类？谢谢您的帮助.

我有一个使用相当多的演员的应用程序:准确地说是25,000.它使用Scala 2.7.7并在jdk6_u18上运行.它基本上监听和处理市场数据,并且几乎没有状态.

它从每天上午8点02分开始,并在一小时内崩溃了OutOfMemoryError."啊哈"你说,"你有内存泄漏!" 除了当我重新启动它说,它从来没有,永远再次崩溃的一天的休息!尽管美国市场在下午2:30开放,但GC和CPU开销都有所上升.

一些轶事发现:

• 它在Solaris上运行.当我用在Linux上运行它,它永远不会崩溃可言.
• 我已经尝试搞乱代堆大小调整,分配更多内存等等.我认为没有区别
• 当我verbose:gc打开时,收集器的行为似乎有所不同

一些问题出现了:

1. 为什么Linux和Solaris之间的程序行为会有所不同？
2. 为什么在8.02开始和8.42开始之间的行为会有所不同？
3. 我听说演员库有一些内存泄漏问题.他们是什么时候,他们什么时候修好了,我怎么能发现这里有什么"相似"的东西？(在jhat中寻找的东西等)
4. 有没有人知道可能会发生什么？

我现在正试图G1看看这是否有所不同.我明天会更新这个问题!

G1的一些输出带有详细:gc on

我想我刚刚抓住了这个行为:

600.290:[全GC 255M-> 144M(256M),1.5772616秒]
602.084:[GC暂停(年轻)227M-> 145M(256M),0.0556769秒]
602.418:[全GC 254M-> 144M(256M),1.6415216秒]
604.279:[GC暂停(年轻)227M-> 145M(256M),0.0415157秒]
604.602:[全GC 255M-> 145M(256M),1.6041762秒]
606.422:[GC暂停(年轻)227M-> 145M(256M) ),0.0237441秒]
606.710:[全GC 254M-> 145M(256M),1.6022185秒]

然后稍后(你可以看到完整的GC需要更长的时间并且回收更少)

849.084:[全GC 254M-> 176M(256M),1.9658754秒]
851.191:[GC暂停(年轻)228M-> 176M(256M),0.0218611秒]
851.414:[全GC 254M-> 176M(256M),1.9352357秒]
853.492:[GC暂停(年轻)228M-> 176M(256M),0.0224688秒]
853.716:[全GC 254M-> 176M(256M),1.9339705秒]
855.793:[GC暂停(年轻)228M-> 176M(256M) ),0.0215707秒]
856.009:[全GC 254M-> 176M(256M),1.9805797秒]
858.137:[GC暂停(年轻)228M-> …

如何List在Scala 2.7.5中添加元素,而无需创建新元素List而不使用已弃用的解决方案.

正如我自己对自己的问题的回答一样,我遇到了处理大量事件的情况.每个事件都以完全相同的方式处理,甚至可以独立于所有其他事件处理每个事件.

我的程序利用了Scala并发框架,并且涉及的许多过程都被建模为Actors.由于ActorS程序的消息顺序,他们不是非常适合于这个特定的问题(即使我的其他演员在执行哪些操作是连续的).因为我希望Scala"控制"所有线程创建(我假设它首先有一个并发系统),我似乎有两个选择:

1. 将事件发送到我控制的事件处理器池
2. 让我Actor通过其他机制同时处理它们

我原以为#1否定了使用actors子系统的要点:我应该创建多少个处理器actor？是一个明显的问题.这些东西据说对我来说是隐藏的,并由子系统解决.

我的回答是做以下事情:

val eventProcessor = actor {
  loop {
    react {
      case MyEvent(x) =>
        //I want to be able to handle multiple events at the same time
        //create a new actor to handle it
        actor {
          //processing code here
          process(x)
        }
    }
  }
}

有更好的方法吗？这是不正确的？

编辑:一个可能更好的方法是:

val eventProcessor = actor {
  loop {
    react {
      case MyEvent(x) =>
        //Pass processing to the …

我需要在某些类型的集合中存储键/值信息.在C#中,我会定义一个这样的字典:

var entries = new Dictionary<string, int>();
entries.Add("Stop me", 11);
entries.Add("Feed me", 12);
entries.Add("Walk me", 13);

然后我会访问这些值:

int value = entries["Stop me"];

我如何用Java做到这一点？我已经看过了一些例子ArrayList,但如果可能的话,我想要使用泛型的解决方案.

我编写了这个方便的通用函数,用于将集合集合转换为单个集合:

public static <T> Set<T> makeSet(Collection<Collection<T>> a_collection) {
    Iterator<Collection<T>> it = a_collection.iterator();
    Set<T> result = new HashSet<T>();
    while (it.hasNext()) {
        result.addAll(it.next());
    }
    return result;
}

然后我试着打电话给它:

    List<List<String>> resultLists = ... ;
    Set<String> labelsSet = CollectionsHelper.makeSet(resultLists);

我收到以下错误:

<T>makeSet(java.util.Collection<java.util.Collection<T>>) in CollectionsHelper 
cannot be applied to (java.util.List<java.util.List<java.lang.String>>)

现在a List 是a Collection,a String 是a T.那么为什么这不起作用,我该如何解决呢？

我只是偶然发现了Tony Morris 关于Java的博客文章之一以及该语言的一个基本问题:为集合定义一个定制的平等关系.这是我认为是一个大问题,并想知道是否有一些scala解决方案.

经典问题表现在考虑交易.假设我在@ 150p进行了两笔+100沃达丰股票交易.这两笔交易是平等的,是吗？除非他们不是同一笔交易.对于普通的真实世界系统,使用持久性或序列化,我不能依赖身份来告诉我两个引用是否属于同一行业!

所以我想要的是能够创建一个我可以传递Equality-relation的集合:

val as = CleverSet[Trade](IdEquality)
val bs = CleverSet[Trade](EconomicsEquality)

我如何以有效的方式实现我的集合(除非EqualityRelation还定义了一种hash机制)？

trait EqualityRelation[T] {
  def equal(t1: T, t2: T) : Boolean
  def hash(t: T) : Int
}

所以问题是:

• 有没有提供这种能力的图书馆？
• 有没有办法在Scala中做到这一点？

似乎带有隐含,添加到现有的scala Set类型将是一件非常容易的事情.

Scala是否有Array类中的Rubys'pert_slice版本？

任何一直关注托尼莫里斯博客和斯卡拉练习的人都知道这两种类型的签名是等价的:

trait MyOption1[A] {
  //this is a catamorphism
  def fold[B](some : A => B, none : => B) : B 
}

和:

trait MyOption2[A] {
  def map[B](f : A => B) : MyOption2[B]
  def getOrElse[B >: A](none : => B) : B
}

此外,已经指出该类型是单独居住的(即该类型的所有实现都完全等效).我可以猜测证明这两种类型的等价性,但实际上并不知道从单一居住声明开始.如何证明这一点？

如果我有一个Bifunctor[A,A]bf 实例,一个函数f : A => A和一个Boolean值p:

def calc[A, F[_,_]: Bifunctor](p: Boolean, bf: F[A, A], f: A => A): F[A, A] = {
  val BF = implicitly[Bifunctor[F]]
  BF.bimap(bf, (a : A) => if (p) f(a) else a, (a : A) => if (!p) f(a) else a)
}

我怎样才能更简洁(更具说服力)？基本上我试图在依赖于某个谓词的bifunctor(例如a Tuple2)的一侧调用一个函数.如果谓词为真,我想映射LHS和RHS,如果它是假的

val t2 = (1, 2)
def add4 = (_ : Int) + 4
calc(true, t2, add4) //should be (5,2)
calc(false, t2, …