Long.valueOf 与 Long.parseLong的区别

在写代码的时候经常会碰到各种数据类型转换的问题，实现同样的数据类型转换功能，细心的同学会发现，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;
    }

从上面的代码中可以看出，它们数据格式转换的步骤是这样子的：

1. 对字符串判空
2. 对基数进行校验，看基数是否在合法范围之内（2到36之间，包含边界）。从注释中可以看出，常用的基数有2、8、10、16、36这几种
3. 判断正负性，然后将每一位乘以基值（基数^第几位），一步步得到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性能比较好