在写代码的时候经常会碰到各种数据类型转换的问题，实现同样的数据类型转换功能，细心的同学会发现，jdk提供多种不同转方式。这次项目中碰到了字符串类型转换为Long类型的问题，比较一下valueOf跟parseLong这两种不同的转换方法。
两种实现方式的源代码比较
Long.parseLong的源代码
public static long parseLong(String s) throws NumberFormatException {
return parseLong(s, 10);
}
Long.valueOf的源代码
public static Long valueOf(String s) throws NumberFormatException
{
return Long.valueOf(parseLong(s, 10));
}
从它们各自实现的代码中，我们可以看出，它们都调用了一个parseLong的方法。不同的地方是，Long.valueOf对parseLong的返回结果调用了Long.valueOf方法进一步处理了一下。
我们先看一下它们共同方法parseLong的实现原理。
共同之处
public static long parseLong(String s, int radix)
throws NumberFormatException
{
if (s == null) {
throw new NumberFormatException("null");
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
long result = 0;
boolean negative = false;
int i = 0, len = s.length();
long limit = -Long.MAX_VALUE;
long multmin;
int digit;
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Long.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
result -= digit;
}
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}
从上面的代码中可以看出，它们数据格式转换的步骤是这样子的：
对字符串判空对基数进行校验，看基数是否在合法范围之内（2到36之间，包含边界）。从注释中可以看出，常用的基数有2、8、10、16、36这几种判断正负性，然后将每一位乘以基值（基数^第几位），一步步得到long类型的数值。
这里有一点比较有意思。它是如何将一个character转换成一个数值类型的。无聊继续扒一扒。
public static int digit(int codePoint, int radix) {
return CharacterData.of(codePoint).digit(codePoint, radix);
}
我们先看一下CharacterData.of是做什么用。
static final CharacterData of(int ch) {
if (ch >>> 8 == 0) { // fast-path
return CharacterDataLatin1.instance;
} else {
switch(ch >>> 16) { //plane 00-16
case(0):
return CharacterData00.instance;
case(1):
return CharacterData01.instance;
case(2):
return CharacterData02.instance;
case(14):
return CharacterData0E.instance;
case(15): // Private Use
case(16): // Private Use
return CharacterDataPrivateUse.instance;
default:
return CharacterDataUndefined.instance;
}
}
}
}
这段代码它是判断一个字符的类型，这里共有7种类型（有兴趣的童鞋可以去研究一一下这7种类型的字符），接下来根据字符的类型来选择将字符转化为数字的方法。下面这一段是latin类型的字符转化为数字类型实现方法。
int digit(int ch, int radix) {
int value = -1;
if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
int val = getProperties(ch);
int kind = val & 0x1F;
if (kind == Character.DECIMAL_DIGIT_NUMBER) {
value = ch + ((val & 0x3E0) >> 5) & 0x1F;
}
else if ((val & 0xC00) == 0x00000C00) {
// Java supradecimal digit
value = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
}
}
return (value < radix) ? value : -1;
}
不同之处
1、返回的对象不同 Long.valueOf()返回的是一个原始类型，Long.valueOf()返回的是一个Long装箱对象。这里如果只需要基础数据类型，用这种方法相对性能更好。 2、处理步骤有差异 Long.valueOf在返回基础类型时候，并将基础类型封装成了对象。这里有个点比较有意思。
public static Long valueOf(long l) {
final int offset = 128;
if (l >= -128 && l <= 127) { // will cache
return LongCache.cache[(int)l + offset];
}
return new Long(l);
}
这里，对-128到127之间的long类型的数据封装成静态对象数组，下次取的时候直接从数组中取，不用再次构建。这对于-128到127之间的字符串转化为Long对象，性能有一点提升。
总结：
在字符串转换为long类型的数据时，如果只需要转换为基础类型，用Long.parseLong性能较好；如果需要获得Long对象，并且数值在-128到127之间，Long.valueOf性能比较好