标签: scala-java-interop

我有一个Java方法接受类型的参数Map<Long, Foo>.我试图在Scala 2.8.1中为该方法编写单元测试并传入一个文字Map[Long, Foo].

我的代码看起来像这样:

import collection.JavaConversions._
x.javaMethod(asJavaMap(Map(1L -> new Foo, 2L -> new Foo)))

编译器给我以下错误:

error: type mismatch;
found   : scala.collection.immutable.Map[scala.Long,Foo]
required: scala.collection.Map[java.lang.Long,Foo]

我也试过了

import collection.JavaConverters._
x.javaMethod(Map(1L -> new Foo, 2L -> new Foo))

和

import collection.JavaConversions._
x.javaMethod(Map(1L -> new Foo, 2L -> new Foo))

并得到错误:

error: type mismatch;
found   : scala.collection.immutable.Map[scala.Long,Foo]
required: java.util.Map[java.lang.Long,Foo]

我该怎么做呢？

如果我定义一个Scala类:

 class X(i:Int) {
   println (i)
 }

如何在Java代码中使用此类？

[编辑]实际上,我的问题稍微复杂一些

我有一个抽象的课

 abstract class X(i:Int) {
   println (i)
   def hello(s:String):Unit
 }

我需要在Java代码中使用它.是否可以轻松完成？

[EDIT2]考虑以下代码

 object B {
    case class C(i:Int)
 }
 abstract class X(i:Int) {
   println (i)
   def hello(a:B.C):Unit
 }

在这种情况下,以下java代码在Netbeans IDE中出错,但构建正常:

 public class Y extends X  {
    public void hello(B.C c) {
       System.out.println("here");
    }
    public Y(int i) {
       super(i);
    }
 }

我得到的错误是:

hello(B.C) in Y cannot override hello(B.C) in X; overridden method is static, final

Netbeans 6.8,Scala 2.8.

截至目前,我认为唯一的解决方案是忽略NB错误.

这是一张显示我得到的确切错误的图片:

来自Scala 编程语言概述，第二版：

// Scala
object PrintOptions {
    def main(args: Array[String]): Unit = {
        System.out.println("Options selected:")
        for (val arg <- args)
            if (arg.startsWith("-"))
                System.out.println(" " + arg.substring(1))
    }
}

在上面的例子中，Scala 程序调用方法startsWith 和substringof String，它是在 Java 中定义的一个类。它还访问outJava 类的静态字段System，并调用其（重载）println方法。即使 Scala 没有静态类成员的概念，这也是可能的。事实上，每个 Java 类在 Scala 中都被视为两个实体，一个包含所有动态成员的类和一个包含所有静态成员的单例对象。

我理解将 Scala 的伴随对象转换为 Java 字节码，但我不确定对于相反的示例（从 Java 到 Scala），上块引用中的粗体文本“在 Scala 中看到”究竟是什么意思。

这是否意味着具有静态成员的 Java 类在 Scala 中实际上被转换或解释为两个实体？或者我的两个假设都是错误的？

如何将Scala转换Array[Int]为Java Integer[]？似乎默认是将 int 转换为int[]，这不是定义为的方法的正确参数

public static <T extends Comparable<? super T>> T[] merge(T[] xs)

编译失败并出现以下错误

type mismatch;
 found   : Array[Int]
 required: Array[? with Object]
Note: Int >: ? with Object, but class Array is invariant in type T.
You may wish to investigate a wildcard type such as `_ >: ? with Object`. (SLS 3.2.10)
      val res = SimpleSort.merge(xs)

                             ^

我们在尝试使用 Java 中的 Scala 代码时遇到问题。我们正在寻找一种方法来自动桥接各种 Scala 和 java 集合，而无需在我们的 Java 代码中进行显式转换。当地方很少时，这样做是合理的，但如果它广泛传播并不断添加新的 scala 类，它就会变得不切实际。

例如，在我们的 Scala 代码中，我们有一些这样的类（其中很多）：

case class Product(id: String, group: String, attributes : Map[String,String])

def fooWithProducts(products : Seq[Product]) = ...

// create a product
val p1 = Product("id1","group1", Map("attribute1" -> "value1","attribute2" -> "value2")

val p2 = Product("id2","group1", Map("attribute1" -> "value1","attribute2" -> "value2")

fooWithProducts(Seq(p1,p2))

当我们想用 Java 编写类似的代码时，它变得非常麻烦，我们需要在所有地方添加很多辅助样板：

// JAVA
// create a product
HashMap<String, String> attributes = new HashMap<String, String>();
attributes.put("my-attribute","my-value");

// create a scala collection
scala.collection.immutable.Map<String, String> scalaAttributes = …

几乎每个 Scala 版本都以非向后兼容的方式更改了集合转换的方式。是否有更好的解决方案，与版本无关并且不依赖于 Scala 发行版？

我不介意使用一些第三方库。

经过几天的搜索，我需要您的帮助来解决我的问题。

我有一个java程序，我想调用一个用scala编写的库，jar在类路径中。

Scala 主类：

object Program{
  def main(args: Array[String]): Unit = {
    ...
  }

  case class Config(param1, param2) {

    def parseProgramFromFiles(){}
    ...

  }

}

我正在尝试使用实例化配置

Program.Config config = new Program.Config(param1, param2);

我收到此错误：java：包程序不存在

程序在默认包中

谢谢

我有返回此类型的java API:

ArrayList[ArrayList[String]] = Foo.someJavaMethod()   

在scala程序中,我需要将上面的类型作为参数发送到类型为的scala函数"bar"

def bar(param: List[List[String]]) : List[String] = {

}

所以我称之为:

val list = bar(Foo.someJavaMethod())

但这不起作用,因为我得到编译错误.

我以为有这个导入

import scala.collection.JavaConversions._ 

将在Java和Scala集合之间进行隐式自动转换.

我也试过用过:

Foo.someJavaMethod().toList 

但这也不起作用.

这个问题的解决方案是什么？

我正在为Play 2框架的SecureSocial插件编写持久层.我在https://github.com/play-modules/modules.playframework.org/blob/master/app/models/ss/MPOOAuth2Info.java上找到了一个例子:

package models.ss;

import models.AbstractModel;
import securesocial.core.java.OAuth2Info;
import javax.persistence.Entity;

@Entity
public class MPOOAuth2Info extends AbstractModel
{
    public String accessToken;

    public String tokenType;

    public Integer expiresIn;

    public String refreshToken;

    public MPOOAuth2Info()
    {
        // no-op
    }

    public MPOOAuth2Info(OAuth2Info oAuth2Info)
    {
        this.accessToken = oAuth2Info.accessToken;
        this.tokenType = oAuth2Info.tokenType;
        this.expiresIn = oAuth2Info.expiresIn;
        this.refreshToken = oAuth2Info.refreshToken;
    }

    public OAuth2Info toOAuth2Info()
    {
        OAuth2Info oAuth2Info = new OAuth2Info();

        oAuth2Info.accessToken = this.accessToken;
        oAuth2Info.tokenType = this.tokenType;
        oAuth2Info.expiresIn = this.expiresIn;
        oAuth2Info.refreshToken = this.refreshToken;

        return oAuth2Info;
    } …

在伴侣对象上定义val时,如下所示:

object Foo { val bar = 3 }

Scala生成静态最终方法:

$ scalac Foo.scala && javap Foo
public final class Foo {
  public static int bar();
}

有没有办法让它生成静态字段而不是静态方法？

FWIW,我需要它,因为我有现有的编译Java代码,我需要保持二进制兼容性.