小编Jus*_*s12的帖子

在下面的:

 scala> (new String(Array[Byte](1, 2, 3, -1, -2, -127))).getBytes
 res12: Array[Byte] = Array(1, 2, 3, -1, -2, 63)

为什么-127转换为63？以及如何将其恢复为-127

[编辑:]下面的Java版本(以显示它不仅仅是"Scala问题")

c:\tmp>type Main.java
public class Main {
    public static void main(String [] args) {
        byte [] b = {1, 2, 3, -1, -2, -127};
        byte [] c = new String(b).getBytes();
        for (int i = 0; i < 6; i++){
            System.out.println("b:"+b[i]+"; c:"+c[i]);
        }
    }
}
c:\tmp>javac Main.java
c:\tmp>java Main
b:1; c:1
b:2; c:2
b:3; c:3
b:-1; c:-1
b:-2; c:-2
b:-127; c:63

是否有任何真正的理由return在Scala 中提供声明？(除了更"对Java友好")

一种方法是这样

list.distinct.size != list.size

有没有更好的方法？拥有一个containsDuplicates方法本来不错

我有以下代码:

object Foo {
 private var ctr = 0L

 def bar = {
   ctr = ctr + 1
   // do something with ctr
 }
}

要求是ctr值只应使用一次.在我的情况下,相同的值ctr被重用.我的理论是,这是因为Foo.bar在不同的线程中同时调用(这是我可以得出的唯一结论).我有以下修改过的代码作为修复.

object Foo {
 private var ctr = 0L
 def getCtr = synchronized{
   ctr = ctr + 1
   ctr
 }
 def bar = {
   val currCtr = getCtr
   // do something with currCtr
 }
}

我找不到synchronized在Scala中使用该方法的好指南.任何人都可以告诉我,如果上述代码将解决我的问题.

编辑:基于以下评论,我认为AtomicLong对我来说是最好的解决方案:

import java.util.concurrent.atomic.AtomicLong
private val ctr = new AtomicLong …

我有一个用Scala编写的应用程序,我的一些团队成员想要它的Java版本.它是一个演示应用程序,使用另一个用Scala编写的API,他们希望Java版本的应用程序能够使用Java中的API.但是,应用程序有点大,我不想手动重新使用Java(他们不想学习Scala).是否有任何工具可以从Scala代码自动生成(可读)Java代码？

Scala REPL的一个有趣特性是,如果您删除%SCALA_HOME%\lib目录中的任何jar ,它可以从REPL导入.我在那里有几个罐子,我经常需要找出哪些罐子可以包括在内.所以我总是要打开另一个命令窗口,找出该目录中存在哪些jar.如果REPL允许我执行系统命令,如这将是巨大dir或者ls,或者至少在名单上面的lib目录下所有的罐子.在REPL中调用shell命令最简单的方法是什么(如果有的话)？

我有一场Java战争,我希望在AWS上使用弹性beanstalk.我有证书,但我无法弄清楚如何将它附加到我的单实例应用程序.

所有的howtos描述了如何将证书附加到弹性负载均衡器,但没有关于如何在没有负载均衡器(即单个实例)的情况下执行此操作的文档.

我不想使用负载均衡器,因为它需要额外的费用(在测试环境中不需要).

任何帮助将不胜感激.

我发现当使用模式匹配替代(对于字符串)时,Scala接受以大写字母开头的变量(在下面的示例中,MyValue1和MyValue2),但不接受以小写字母(myValue1,myValue2)开头的变量.这是Scala的错误还是功能？我在2.8版本中得到了这个.如果这是一个功能,任何人都可以解释其背后的基本原理吗？这是我使用的代码:

val myValue1 = "hello"
val myValue2 = "world"
val MyValue1 = "hello"
val MyValue2 = "world"

var x:String = "test"

x match {
  case MyValue1 | MyValue2 => println ("first match")
  case myValue1 | myValue2 => println ("second match")
}

在运行时,我得到以下内容:

scala> val myValue1 = "hello"
myValue1: java.lang.String = hello

scala> val myValue2 = "world"
myValue2: java.lang.String = world

scala> val MyValue1 = "hello"
MyValue1: java.lang.String = hello

scala> val MyValue2 …

在Scala中,有reverse列表方法.这种方法的复杂性是什么？简单地使用原始列表是否更好,并始终记住列表与我们期望的相反,或者reverse在操作之前明确使用.

编辑:我真正感兴趣的是获取原始列表的最后两个元素(或反向列表的前两个).

所以我会这样做:

val myList = origList.reverse
val a = myList(0)
val b = myList(1)

这不是一个循环,只是我的库中的一次性事物......但如果其他人使用该库并将其置于循环中,则不在我的控制之下.

Scala编译器当前无法推断递归方法的返回类型,如以下代码所示

def foo(i:Int) = if (i > 0) foo (i-1) else 0

上述声明中是否存在任何矛盾？(即,除了Int可能以外的任何类型？)

我可以想象,在更复杂的例子中,很难推断出类型.

是否有可能进一步描述递归方法的情况,我们可以(不)推断出类型？

[编辑:]编译器足够聪明,可以发现这String是不正确的.

scala> def foo(i:Int):String = if (i > 0) foo (i-1) else 0
<console>:5: error: type mismatch;
found   : Int(0)
required: String