标签: scala-java-interop

我需要一个可以从Scala和Java调用的构建器库.使用默认的命名参数在Scala中足够简单.但是如何从Java调用此代码？见下文.或者我应该使用更流行的两种语言更常见的API？

斯卡拉:

case class Person(gender:Gender.Value, firstName:String, lastName:String){
  def fullName = lastName+", "+firstName
  override def toString = firstName+","+lastName+","+gender
}
case class PersonBob(
  gender:Gender = GenderBob().build,
  firstName:String =  null,
  lastName:String = null) {
  def build = Person(
    gender,
    if(firstName == null) NameBob(if(gender==Gender.Male) engMaleNames 
      else engFemaleNames).build else firstName,
    if(lastName==null) NameBob(engLastNames).build 
      else lastName
    )
  }

用法:

val p1 = PersonBob().build
val p2 = PersonBob(lastName = "Jones").build

Java用法:

Person p1 = ?
Person p2 = ?

我需要在运行时从给定的类获取所有接口（全部加载在类加载器中）。

例如，如果一个类是这样声明的：

trait B
trait C
trait D    
class A extends B with C with D

我想在运行时获取以下信息：A 依赖于 B、C 和D。java getInterfaces() （或 clapper 库中的interfaces()）方法仅给出第一个依赖项，即：A 依赖于 B。

有办法实现吗？

我想通过反思，但我不知道如何？

我确实想在我的Java应用程序中使用一个Scala库（仅以Scala编写）。我正在尝试评估我是否可以做到这一点，而不会遭受任何隐藏的棘手动物/洞穴/陷阱的困扰。所以我直接去了Scala FAQ，他们回答了这个问题（嗯，有点）：

从Scala代码访问Java类完全没有问题。使用Java中的Scala类可能会很棘手，特别是如果您的Scala类使用了泛型，多态方法或抽象类型等高级功能时，尤其如此。

然后，我发现了其他几个站点（例如this站点），这些站点似乎表明从Java内部调用Scala没问题，因为它都是已编译的JVM字节码。

因此，我有两个非常矛盾的信息源，我被困在中间，试图确定哪些用例使从Java调用Scala 变得 “ 棘手 ”，哪些用例是直接的。有任何想法吗？

是否可以从隐式类定义自动生成用于互操作的配套 Java 静态方法？

例如：

class Foo()
object FooOps {
    implicit class FooOps(foo: Foo) extends AnyVal {
      def baz = "hello"
    }
}

可以作为new Foo().baz. 然而，这在 Java 中是相当不方便和不惯用的。是否可以为 Java 自动生成（例如通过宏）静态方法，就像 Kotlin 为扩展方法所做的那样？例如：

object FooOps {
    @MagicAnnotation 
    implicit class FooOps(foo: Foo) extends AnyVal {
      def baz(n: Int) = "hello"
    }
    // generated:
    def baz(foo: Foo, n: Int) = foo.baz(n)
}

我正在编写一个包装器,它将Scala ObservableBuffer和fires事件与Eclipse/JFace Databinding框架兼容.

在Databinding框架中,有一个抽象ObservableList来装饰普通的Java列表.我想重用这个基类,但即使这个简单的代码也会失败:

val list = new java.util.ArrayList[Int]
val obsList = new ObservableList(list, null) {}

有错误:

illegal inheritance; anonymous class $anon inherits different type instances of trait Collection: java.util.Collection[E] and java.util.Collection[E]
illegal inheritance; anonymous class $anon inherits different type instances of trait Iterable: java.lang.Iterable[E] and java.lang.Iterable[E]

为什么？它与原始类型有关吗？ObservableListimplements IObservableList,扩展原始类型java.util.List.这是预期的行为,我该如何解决它？

下面的代码将List类型转换为类型List<TestObj>列表,List<List<String>> 其中type 中的每个List元素List<List<String>>都是大小为1的String List.这是一个非常迭代的方法,可以使用scala将其转换为更实用的方法吗？一个可能的解决方案:模式匹配List<String>并且只是为每个头元素创建一个新的List？

以下java代码的输出:

strVal is 1 
New list 
strVal is 2 
New list


public class Driver {

        public static void main (String args[]){

        /**
         * Setup the test list data
         */
        List<String> l = new ArrayList<String>(); 
        l.add("1");
        l.add("2");     
        TestObj t = new TestObj();
        t.setTestList(l);
        t.setName("test");
        List<TestObj> tList = new ArrayList<TestObj>();
        tList.add(t);

        /**
         * Convert the list to a new data structure
         */
        List<List<String>> l3 = new ArrayList<List<String>>();
        List<String> l2 = new …

我有一个scala案例类.我试图用java中的obj.copy()复制它,但我没有看到任何这样的方法

我目前所做的是一个解决方法:

  // Hack, copy was not visible from java code.
  def doCopy(): MyCaseClass = {
    return this.copy()
  }

现在可以从java中看到doCopy().有没有比这个黑客更好的方法呢？

我在scala中有这个:

object Tester {
  def apply[T : Manifest](description: String, initValue: T) = new Tester[T](description, initValue)
  implicit def TesterToValue[T](j: Tester[T]): T = j.value
}

class Tester[T : Manifest](someData: String, initValue: T) {
  private var value = initValue
  def getValue : T = value
}

这让我做到了

val t1 = JmxValue("some data", 4)

我正在尝试创建一个这样的实例是java,到目前为止我没有运气我尝试过:

Tester t1 = Tester<Integer>("data", 0);
Tester<Integer> t1 = Tester<Integer>("data", 0);
Tester t1 = Tester("data", 0);
Tester t1 = new Tester<Integer>("data", 0);
Tester<Integer> t1 = new Tester<Integer>("data", 0);

在java中使用scala泛型类是否有一些限制？或者我只是在做一些可怕的错误

我正在尝试实现包装数学Java函数的泛型函数。为简单起见，我们可以假定Java函数（Java 7）接受一个参数并返回结果，均为java.lang.Double类型。当然，包装器函数应该带有一个参数和一个结果，它们都是通用类型但为数字类型A。问题是我无法在包装器函数中将结果强制转换回类型A。问题出在哪里/什么地方？

注意：（我是Scala的新手，并使用以下参考资料来解决该问题。）

• 我使用隐式类型特征Numeric强制模板类型为数字。如何在Scala中实现通用数学函数
• 我找到了我不完全了解的“ import scala.collection.JavaConversions._”，但是在我看来，这只是为了转换Java集合，并不能解决我的问题，对吗？遍历Scala中的Java集合
• 如此处所述，我尝试使用Manifest强制执行正确的强制转换（变量B），但最终导致异常java.lang.ClassCastException。具有参数化类型的Scala asInstanceOf

变体A

package test

object mytest {
  def f[A](x: A)(implicit num: Numeric[A]): A = {
    val result = new java.lang.Double(num.toDouble(x))
    result.asInstanceOf[A]
  }

  def main(args: Array[String]) {
    // 'Some code'
  }
}

“某些代码” A1

result val result = f(3)

输出：

Exception in thread "main" java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.Integer
    at scala.runtime.BoxesRunTime.unboxToInt(BoxesRunTime.java:105)
    at test.mytest$.main(test.scala:10)
    at test.mytest.main(test.scala)

“某些代码” A2

println(f(3))

输出：

3.0

“某些代码” A3

println(f(3).getClass)

输出：

int

变体B

package test …

我正在尝试从Java代码实例化Kafka Scala案例类,它具有以下签名:

case class OffsetFetchRequest(groupId: String,
                          requestInfo: Seq[TopicAndPartition],
                          versionId: Short = OffsetFetchRequest.CurrentVersion,
                          correlationId: Int = 0,
                          clientId: String = OffsetFetchRequest.DefaultClientId)

我能够发送所有请求的参数,除了Seq[TopicAndPartition].

在Java方面,我有以下代码:

OffsetFetchRequest offsetFetchRequest = new OffsetFetchRequest(
                                                "someGroup", 
                                                topicAndPartitions, 
                                                (short)1, 
                                                1, 
                                                "clientId");

正如所料,a java.util.List与Scala不兼容Seq.不过,我已经尝试了所有类型的转换方法JavaConversions和JavaConverters,我找不到任何适合这种情况.

如何seq从正常java.util.List甚至是java.util.Collection？创建Scala ？或者我接近这个错误？