文本讨论一下Scala语言基本类型的实现方式
Java基本类型
Java的数据类型大致可以分为两类：基本（Primitive）类型和对象类型。基本类型一共有8种，分别是boolean、byte、short、char、int、long、float、double。为了把基本类型融入OO系统，Java提供了包装类（Wrapper）。包装类在包java.lang里，一共8个，分别与基本类型一一对应，它们是：Boolean、Byte、Short、Character、Integer、Long、Float和Double。Java5引入的自动装箱拆箱（Autoboxing
and Unboxing）语法让基本类型和OO系统结合的更自然，但仍然不够完美。
Scala基本类型
Scala在Java的基础上迈出了一大步，从语法层面彻底消灭了Primitive类型。也就是说，一切皆是对象，如下面代码所示：
val x = 1
println(x.toString)
3.to(8).foreach {
i => println(i)
}
和Java的8种基本类型相对应，Scala也定义了8种基本类型，它们是：Boolean、Byte、Short、Char、Int、Long、Float和Double。这8种基本类型都定义在scala包里。有趣的是，这8种基本类型虽然有相应的类定义，但是和其他类还是有区别的：这些类的实例并不是对象，而是直接映射为相应的primitive类型。比如，下面是Int类的部分代码：
package scala
/** `Int`, a 32-bit signed integer (equivalent to Java's `int` primitive type) is a
* subtype of [[scala.AnyVal]]. Instances of `Int` are not
* represented by an object in the underlying runtime system.
*
* There is an implicit conversion from [[scala.Int]] => [[scala.runtime.RichInt]]
* which provides useful non-primitive operations.
*/
final abstract class Int private extends AnyVal {
...
}
底层使用Primitive类型
虽然从语法上来看，基本类型和对象类型已经没有任何区别。但是在底层，Scala使用的仍然是primitive类型。比如下面这个方法：
def collect(x: Int, y: Int): Array[Int] = {
Array(x, y + 1)
}
经过Scala编译之后再反编译，可以得到下面的Java代码：
public int[] collect(int x, int y) {
return new int[] {x, y + 1};
}
包装为Java包装类型
必要时，Scala会把基本类型包装成相应的Java包装类型，比如下面这个方法：
def boxToXXX() = {
val x = 1
val str = x.toString()
val hc = x.hashCode()
}
反编译得到下面的Java代码：
int x = 1; Integer boxedX = scala.runtime.BoxesRuntime.boxToInteger(x); boxedX.toString(); boxedX.hashCode();
BoxesRuntime类的boxToInteger()方法调用了Integer的valueOf()方法，如下所示：
public static java.lang.Integer boxToInteger(int i) {
return java.lang.Integer.valueOf(i);
}
隐式转换为Java包装类型
基本类型也可以通过隐式转换变为Java包装类型，比如下面这个方法：
def implicitConversion() = {
val x = 1
val y = 2
x.compareTo(y)
}
反编译之后，得到下面的Java代码：
int x = 1; int y = 2; Integer boxedX = scala.Predef$.MODULE$.int2Integer(x); Integer boxedY = scala.Predef$.MODULE$.int2Integer(y); boxedX.compareTo(boxedY);
隐式转换方法定义在Predef里，下面是Predef的相应代码：
object Predef {
implicit def int2Integer(x: Int) = java.lang.Integer.valueOf(x)
}
隐式转换为RichXXX
为了给基本类型添加更多的方法，Scala给每个基本类型都定义了一个新的包装类，这些包装类在scala.runtime包里，分别是：RichBoolean、RichByte、RichShort、RichChar、RichInt、RichLong、RichFloat和RichDouble。比如下面这个方法：
def richXXX() = {
val x = -1
x.abs
}
反编译之后，得到下面的Java代码：
int x = -1; RichInt richX = scala.Predef$.MODULE$.intWrapper(x); richX.abs();
下面是Predef的相应代码：
object Predef extends LowPriorityImplicits {...}
private[scala] abstract class LowPriorityImplicits {
@inline implicit def intWrapper(x: Int) = new runtime.RichInt(x)
}
隐式转换为BigXXX
为了支持任意精度的整数和小数，Java提供了BigInteger和BigDecimal类，这两个类在java.math包里。Scala在scala.math包里提供了两个类似的类：BigInt和BigDecimal。这两个类都重载了各种运算符，所以使用起来更加自然：
def bigXXX() = {
val x: BigInt = 237
val y = (x * 7) pow 95
}
下面是反编译之后的bigXXX方法：
int x = 237; BigInt bigX = BigInt$.MODULE$.int2bigInt(x); BigInt y = bigX.$times(7).pow(95);
下面是BigInt相应代码：
object BigInt {
implicit def int2bigInt(i: Int): BigInt = apply(i)
}
final class BigInt(val bigInteger: BigInteger) {
def + (that: BigInt): BigInt = new BigInt(this.bigInteger.add(that.bigInteger))
def - (that: BigInt): BigInt = new BigInt(this.bigInteger.subtract(that.bigInteger))
def * (that: BigInt): BigInt = new BigInt(this.bigInteger.multiply(that.bigInteger))
def / (that: BigInt): BigInt = new BigInt(this.bigInteger.divide(that.bigInteger))
def pow (exp: Int): BigInt = new BigInt(this.bigInteger.pow(exp))
}
可见BigInt只是简单的包装Java的BigInteger而已，而且还提供了一个单例对象。为了提高效率，BigInt还采用了和java.lang,Integer类似的缓存优化，把-1024到1024之间的数缓存了起来：
object BigInt {
private val minCached = -1024
private val maxCached = 1024
private val cache = new Array[BigInt](maxCached - minCached + 1)
def apply(i: Int): BigInt =
if (minCached <= i && i <= maxCached) {
val offset = i - minCached
var n = cache(offset)
if (n eq null) { n = new BigInt(BigInteger.valueOf(i.toLong)); cache(offset) = n }
n
} else new BigInt(BigInteger.valueOf(i.toLong))
}
参考资料
《Programming in Scala》第二版
《Scala for the Impatient》