探索Scala（5）-- 基本类型

标签：scala

文本讨论一下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)
}

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()
}

int x = 1;
Integer boxedX = scala.runtime.BoxesRuntime.boxToInteger(x);
boxedX.toString();
boxedX.hashCode();

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)
}

int x = 1;
int y = 2;
Integer boxedX = scala.Predef$.MODULE$.int2Integer(x);
Integer boxedY = scala.Predef$.MODULE$.int2Integer(y);
boxedX.compareTo(boxedY);

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
}

int x = -1;
RichInt richX = scala.Predef$.MODULE$.intWrapper(x);
richX.abs();

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
}

int x = 237;
BigInt bigX = BigInt$.MODULE$.int2bigInt(x);
BigInt y = bigX.$times(7).pow(95);

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))
}

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))
}

参考资料

Scala API

Scala源代码

《Programming in Scala》第二版

《Scala for the Impatient》

探索Scala（5）-- 基本类型

标签：scala

原文地址：http://blog.csdn.net/zxhoo/article/details/40615829