Usando Scala Colecciones (o guayaba) desde Java

que he ido encontrando más y más razones para utilizar Scala en lugar de Java, pero la migración de un gran proyecto existente (por ejemplo, en el trabajo) es difícil y lleva tiempo. Así que he estado investigando formas de utilizar cada vez más de tipo Scala-pensamiento en Java. Específicamente prefiriendo inmutabilidad de razones de simplicidad (que no es sólo para multithreading más).

He aquí una rápida ejecución de prueba de la creación de un mapa inmutable la forma en que lo haría en la Scala, pero hacerlo en Java. Tuve que usar 6 elementos iniciales para hacer esta feria porque la guayaba mapa tiene un constructor de 5 elementos (Scala tiene un constructor de 4 elementos). Me divierte que la solución simple de Java, el que esto está más profundamente arraigada en la programación imperativa, es el único que confiar explícitamente en un cierre léxico para garantizar la inmutabilidad de los elementos subyacentes en el mapa.

   / / Scala  
  val  OP_MAP = mapa (( "+" ,  "Plus" ), 
 ( "-"   "Menos" ), 
 ( "*" ,  "Times" ), 
 ( "/" ,  "Dividido por" ), 
 ( "%" ,  "Modulo" ), 
 ( "^"   "Para el poder de" )) 
 
  / / Google Guava  
  static final  ImmutableMap  OP_MAP = 
  nueva  ImmutableMap.Builder  () 
. puesto ( "+" ,  "Plus" ), 
. puesto ( " - ", " Menos ". ), 
 poner (" * "  "Times" ), 
. puesto ( "/" ,  "dividido por" ), 
. puesto ( "%" ,  "Modulo" ), 
. . puesto ( "^" ,  "Para el poder de" ) 
 construir (); 
 
  / / Java  
  static final  privada Mapa  OP_MAP; 
  estática  
 {Mapa  m =  nueva  HashMap <> (); 
 m.put ( "+" ,  "Plus" ); 
 m.put (" - ", " Menos "); 
 m.put (" * ",  "Times" ); 
 m.put ( "/"   "Dividido por" ); 
 m.put ( "%" ,  "Modulo"  ); 
 m.put ( "^" ,  "Para el poder de" ); 
 OP_MAP = Collections.unmodifiableMap (m);} 
 
 
  / / Scala de Java (basado en el ejemplo anterior descompilación Scala)  
  @ SuppressWarnings ({"sin control", "rawtypes"})  
  static final  WrappedArray > wa = 
 Predef.wrapRefArray (
 (Tuple2  [])  nueva  Tuple2 [] {
  nueva  Tuple2 <> ( "+" ,  "Plus" ), 
  nueva  Tuple2 <> ( "-" ,  " Menos "), 
  nueva  Tuple2 <> (" * "  "Times" ), 
  nueva  Tuple2 <> ( "/"  ,  "dividido por" ), 
  nueva  Tuple2 <> ( " % ", " Modulo "), 
  nueva  Tuple2 <> ( "^" ,  "Para el poder de" )}); 
 
  @ SuppressWarnings ("sin marcar")  
  static final  privado scala.collection.immutable.Map  OP_MAP = 
 (scala . collection.immutable.Map ) 
 scala.Predef $  $  MÓDULO Mapa () aplicar (wa),... 
  

Conclusiones

Constructor de guayaba hace que sea un poco más elegante que la solución simple de Java. Pero a menudo encontrado útil disponer de una colección que es lo mismo que otra con sólo un elemento adicional. Desafortunadamente, no hay put (método) en el mapa que devuelve un nuevo mapa inmutable. Ningún sindicato (), se cruzan (), o las operaciones de diferencia (juego). No hay forEach (), flatmap (), foldl (), foldr () Mapa () u otro iterador.

Mientras que la guayaba es el ganador en la solución de este problema en particular, es sólo un bebé a paso hacia adelante desde la solución de Java recta. Veo que se ha puesto mucho pensamiento en el método CopyOf () de las colecciones de la guayaba, pero me gustaría mucho prefieren iteradores internos etc, que trabajan juntos como una API inmutable como se ha descrito anteriormente. Déjame saber lo que me falta en los comentarios.

Lamentablemente, Java 8 sólo parece reforzar la hipótesis de la mutabilidad en sus nuevas interfaces. Todos los nuevos iteradores modificar la colección subyacente en lugar de devolver una copia superficialmente modificado la forma en que las colecciones Scala hacen. Probablemente estaré pegando con la solución Java sencillo hasta que ponga el paso a Scala. Yo podría estar tentado a concluir algunas colecciones Scala en las clases de Java-amigables que hacen todo lo anterior que he mencionado, pero por supuesto, eso es trabajo …

Gracias a la gente en desbordamiento de pila por su invaluable ayudar descompilación el código Scala!