Estoy aprendiendo Scala y tengo un proyecto Java para migrar a Scala. Quiero migrarlo reescribiendo las clases una por una y comprobando que la nueva clase no rompió el proyecto.

Este proyecto de Java utiliza un montón dejava.util.List yjava.util.Map. En las nuevas clases de Scala me gustaría usar ScalaList yMap tener un código de Scala atractivo.

El problema es que las nuevas clases (las que están incorporadas en Scala) no se integran a la perfección con el código Java existente: las necesidades de Javajava.util.List, Scala necesita su propioscala.List.

Aquí hay un ejemplo simplificado del problema. Hay clasesPrincipal, Lógica, Dao. Se llaman en una línea:Principal -> Lógica -> Dao.

public class Main {
    public void a() {
        List<Integer> res = new Logic().calculate(Arrays.asList(1, 2, 3, 4, 5));
    }
}

public class Logic {
    public List<Integer> calculate(List<Integer> ints) {
        List<Integer> together = new Dao().getSomeInts();
        together.addAll(ints);
        return together;
    }
}

public class Dao {
    public List<Integer> getSomeInts() {
        return Arrays.asList(1, 2, 3);
    }
}

En mi situación, las clases.Principal yDao son clases de marco (no necesito migrarlas). ClaseLógica es lógica de negocios y se beneficiará mucho de las funciones geniales de Scala.

Necesito reescribir la claseLógica en Scala preservando la integridad con las clasesPrincipal yDao. La mejor reescritura sería (no funciona):

class Logic2 {
  def calculate(ints: List[Integer]) : List[Integer] = {
      val together: List[Integer] = new Dao().getSomeInts()
      together ++ ints
  }
}

Comportamiento ideal: listas dentro.Logic2 Son Listas Scala nativas. Todo dentro / fuerajava.util.Lists obtener en caja / sin caja automágicamente Pero esto no funciona.

En cambio, esto funciona (gracias aScala-javautils (GitHub)):

import org.scala_tools.javautils.Implicits._

class Logic3 {
  def calculate(ints: java.util.List[Integer]) : java.util.List[Integer] = {
      val together: List[Integer] = new Dao().getSomeInts().toScala
      (together ++ ints.toScala).toJava
  }
}

Pero se ve feo.

¿Cómo puedo lograr una conversión mágica transparente de listas y mapas entre Java <-> Scala (sin necesidad de hacer toScala / toJava)?

Si no es posible, ¿cuáles son las mejores prácticas para migrar Java -> código de Scala que usajava.util.List ¿y amigos?