¿Qué problemas debo esperar al usar Reflection para interactuar con java.math.BigInteger?

Question

Implemento una implementación más rápida BigInt y no estoy seguro de qué tan lejos debería llegar para proporcionar interoperabilidad con la plataforma subyacente.

Hoy BigInt simplemente se ajusta un BigInteger y el valor bigInteger sólo devuelve el valor envuelta:

class BigInt(val bigInteger: BigInteger) ... 

Porque no estoy envolviendo un tipo Java, que tendría que hacer algo como

final class BigInt private(final val signum: Int, 
          final private[math] val arr: Array[Int]) 
    def bigInteger: java.math.BigInteger = { 
    // Avoid copying of potentially large arrays. 
    val ctor = classOf[java.math.BigInteger] 
       .getDeclaredConstructor(classOf[Array[Int]], classOf[Int]) 
    ctor setAccessible true 
    ctor.newInstance(arr, signum.asInstanceOf[Object]) 
    } 
... 
} 

¿Esto puede causar problemas o hay una mejor manera de hacerlo?

Answer 1

En general, cuando he visto la gente usa constructores o métodos privados (o de otra manera sin papeles) de este tipo, que capturan NoSuchMethodException y proporcionan una alternativa:

object BigInt { 
    import java.math.BigInteger 

    private val toBigInteger: (Array[Int], Int) => BigInteger = try { 
    val ctor = classOf[BigInteger].getDeclaredConstructor(
     classOf[Array[Int]], classOf[Int] 
    ) 
    ctor.setAccessible(true) 

    (arr, signum) => ctor.newInstance(arr, signum.asInstanceOf[Object]) 
    } catch { case _: NoSuchMethodException => 
    (arr, signum) => 
     val buffer = java.nio.ByteBuffer.allocate(arr.length * 4) 
     buffer.asIntBuffer.put(arr) 
     new BigInteger(signum, buffer.array) 
    } 
} 

final class BigInt(final val signum: Int, final val arr: Array[Int]) { 
    def bigInteger = BigInt.toBigInteger(arr, signum) 
} 

también me he movido el negocio fuera de reflexión un objeto complementario para evitar pagar la mayor parte cada vez que llame al bigInteger.