Scala and Java, in one project

Interdependencies

maven-scala-plugin

Scala compiler understands Java code. It can compile Scala even if it depends on Java which is not yet compiled.

mvn clean scala:compile

Java compiler is not so smart. If Java depends on Scala code, it throws error.

mvn clean compiler:compile

Example configuration

      
        org.scala-tools
        maven-scala-plugin
        2.15.2
        
          
            scala-compile-first
            process-resources
            
              add-source
              compile
            
            
              ${scala.version}
              true
              
                -target:jvm-1.7
              
            
          
          
            scala-test-compile
            process-test-resources
            
              testCompile
            
            
              ${scala.version}
              true
              
                -target:jvm-1.7
              
            
          
        
      
      

Are we done?

Types...

Collections

Use conversion Luke

Converter

        object ScalaConverters {

          def toScala[A](jList: java.util.List[A]): List[A] = {
            JavaConverters.asScalaBufferConverter(jList).asScala.toList
          }

          def toScala[A](jCollection: java.util.Collection[A]): Iterable[A] = {
            JavaConverters.collectionAsScalaIterableConverter(jCollection).asScala
          }

          def toScala[A](jSet: java.util.Set[A]): Set[A] = {
            JavaConverters.asScalaSetConverter(jSet).asScala.toSet
          }

          def toScala[A, B](jMap: java.util.Map[A, B]): Map[A, B] = {
            JavaConverters.mapAsScalaMapConverter(jMap).asScala.toMap
          }

          def toJava[A](sList: Seq[A]): java.util.List[A] = {
            new util.ArrayList(JavaConverters.seqAsJavaListConverter(sList).asJava)
          }

          def toJava[A](sCollection: Iterable[A]): java.util.Collection[A] = {
            JavaConverters.asJavaCollectionConverter(sCollection).asJavaCollection
          }

          def toJava[A](sSet: Set[A]): java.util.Set[A] = {
            JavaConverters.setAsJavaSetConverter(sSet).asJava
          }

          def toJava[A, B](sMap: Map[A, B]): java.util.Map[A, B] = {
            JavaConverters.mapAsJavaMapConverter(sMap).asJava
          }
        }
      

Implicit conversion

Converter

Option / Optional

        def toJava[A](sOpt: Option[A]): Optional[A] = {
          sOpt match {
            case Some(a) => Optional.of(a)
            case None => Optional.absent()
          }
        }

        def toScala[A](gOpt: Optional[A]): Option[A] = {
          gOpt.isPresent match {
            case true => Option(gOpt.get())
            case false => Option.empty
          }
        }
      

Thank you!

Szczecin Java Users Group